C# OutputSettings.Markup方法代码示例

		protected override string GetTypeString (IType t, OutputSettings settings)
		{
			if (t.Kind == TypeKind.Unknown) {
				return t.Name;
			}
			
			if (t.Kind == TypeKind.TypeParameter)
				return t.FullName;
			
			var typeWithElementType = t as TypeWithElementType;
			if (typeWithElementType != null) {
				var sb = new StringBuilder ();
			
				if (typeWithElementType is PointerType) {
					sb.Append (settings.Markup ("*"));
				} 
				AppendType (sb, typeWithElementType.ElementType, settings);
				
				if (typeWithElementType is ArrayType) {
					sb.Append (settings.Markup ("["));
					sb.Append (settings.Markup (new string (',', ((ArrayType)t).Dimensions - 1)));
					sb.Append (settings.Markup ("]"));
				}
				return sb.ToString ();
			}
			
			ITypeDefinition type = t.GetDefinition ();
			if (type == null)
				return "";
			
			if (!settings.UseNETTypeNames && type.Namespace == "System" && type.TypeParameterCount == 0) {
				switch (type.Name) {
				case "Object":
					return "object";
				case "Boolean":
					return "bool";
				case "Char":
					return "char";
				case "SByte":
					return "sbyte";
				case "Byte":
					return "byte";
				case "Int16":
					return "short";
				case "UInt16":
					return "ushort";
				case "Int32":
					return "int";
				case "UInt32":
					return "uint";
				case "Int64":
					return "long";
				case "UInt64":
					return "ulong";
				case "Single":
					return "float";
				case "Double":
					return "double";
				case "Decimal":
					return "decimal";
				case "String":
					return "string";
				case "Void":
					return "void";
				}
			}
			
			// output anonymous type
			if (type.IsSynthetic && type.Name == "$Anonymous$")
				return GetTypeReferenceString (type, settings);
			
			var result = new StringBuilder ();
			
			
			var def = type;
			AppendModifiers (result, settings, def);
			if (settings.IncludeKeywords)
				result.Append (GetString (def.Kind));
			if (result.Length > 0 && !result.ToString ().EndsWith (" "))
				result.Append (settings.Markup (" "));
			
			
			if (type.Kind == TypeKind.Delegate && settings.ReformatDelegates && settings.IncludeReturnType) {
				var invoke = type.GetDelegateInvokeMethod ();
				result.Append (GetTypeReferenceString (invoke.ReturnType, settings));
				result.Append (settings.Markup (" "));
			}
			
			
			if (settings.UseFullInnerTypeName && type.DeclaringTypeDefinition != null) {
				bool includeGenerics = settings.IncludeGenerics;
				settings.OutputFlags |= OutputFlags.IncludeGenerics;
				string typeString = GetTypeReferenceString (type.DeclaringTypeDefinition, settings);
				if (!includeGenerics)
					settings.OutputFlags &= ~OutputFlags.IncludeGenerics;
				result.Append (typeString);
				result.Append (settings.Markup ("."));
			}
			result.Append (settings.EmitName (type, type.Name));
			if (settings.IncludeGenerics && type.TypeParameterCount > 0) {
//.........这里部分代码省略.........

        void AppendType(StringBuilder sb, IType type, OutputSettings settings)
        {
            if (type.Kind == TypeKind.Unknown) {
                sb.Append (settings.IncludeMarkup ? settings.Markup (type.Name) : type.Name);
                return;
            }
            // no generics in TypeScript so far.
            /*
            if (type.Kind == TypeKind.TypeParameter) {
                sb.Append (settings.IncludeMarkup ? settings.Markup (type.Name) : type.Name);
                return;
            }
            */
            // no nested type in TypeScript so far.
            /*
            if (type.DeclaringType != null) {
                AppendType (sb, type.DeclaringType, settings);
                sb.Append (settings.Markup ("."));
            }
            */

            var typeWithElementType = type as TypeWithElementType;
            if (typeWithElementType != null) {
                AppendType (sb, typeWithElementType.ElementType, settings);

                if (typeWithElementType is PointerType) {
                    sb.Append (settings.Markup ("*"));
                }

                if (typeWithElementType is ArrayType) {
                    sb.Append (settings.Markup ("["));
                    sb.Append (settings.Markup (new string (',', ((ArrayType)type).Dimensions - 1)));
                    sb.Append (settings.Markup ("]"));
                }
                return;
            }

            // no generics in TypeScript so far.
            /*
            var pt = type as ParameterizedType;
            if (pt != null) {
                if (pt.Name == "Nullable" && pt.Namespace == "System" && pt.TypeParameterCount == 1) {
                    AppendType (sb, pt.TypeArguments [0], settings);
                    sb.Append (settings.Markup ("?"));
                    return;
                }
                sb.Append (pt.Name);
                if (pt.TypeParameterCount > 0) {
                    sb.Append (settings.Markup ("<"));
                    for (int i = 0; i < pt.TypeParameterCount; i++) {
                        if (i > 0)
                            sb.Append (settings.Markup (", "));
                        AppendType (sb, pt.TypeArguments [i], settings);
                    }
                    sb.Append (settings.Markup (">"));
                }
                return;
            }
            */

            var typeDef = type as ITypeDefinition ?? type.GetDefinition ();
            if (typeDef != null) {
                if (settings.UseFullName) {
                    sb.Append (settings.IncludeMarkup ? settings.Markup (typeDef.FullName) : typeDef.FullName);
                } else {
                    sb.Append (settings.IncludeMarkup ? settings.Markup (typeDef.Name) : typeDef.Name);
                }

                // No generics in TypeScript so far.
                /*
                if (typeDef.TypeParameterCount > 0) {
                    sb.Append (settings.Markup ("<"));
                    for (int i = 0; i < typeDef.TypeParameterCount; i++) {
                        if (i > 0)
                            sb.Append (settings.Markup (", "));
                        AppendVariance (sb, typeDef.TypeParameters [i].Variance);
                        AppendType (sb, typeDef.TypeParameters [i], settings);
                    }
                    sb.Append (settings.Markup (">"));
                }
                */
            }
        }

		public void AppendType (StringBuilder sb, IType type, OutputSettings settings)
		{
			if (type.Kind == TypeKind.Unknown) {
				sb.Append (type.Name);
				return;
			}
			if (type.Kind == TypeKind.TypeParameter) {
				sb.Append (type.Name);
				return;
			}
			if (type.DeclaringType != null) {
				AppendType (sb, type.DeclaringType, settings);
				sb.Append (settings.Markup ("."));
			}
			if (type.Namespace == "System" && type.TypeParameterCount == 0) {
				switch (type.Name) {
				case "Object":
					sb.Append ("object");
					return;
				case "Boolean":
					sb.Append ("bool");
					return;
				case "Char":
					sb.Append ("char");
					return;
				case "SByte":
					sb.Append ("sbyte");
					return;
				case "Byte":
					sb.Append ("byte");
					return;
				case "Int16":
					sb.Append ("short");
					return;
				case "UInt16":
					sb.Append ("ushort");
					return;
				case "Int32":
					sb.Append ("int");
					return;
				case "UInt32":
					sb.Append ("uint");
					return;
				case "Int64":
					sb.Append ("long");
					return;
				case "UInt64":
					sb.Append ("ulong");
					return;
				case "Single":
					sb.Append ("float");
					return;
				case "Double":
					sb.Append ("double");
					return;
				case "Decimal":
					sb.Append ("decimal");
					return;
				case "String":
					sb.Append ("string");
					return;
				case "Void":
					sb.Append ("void");
					return;
				}
			}
			
			var typeWithElementType = type as TypeWithElementType;
			if (typeWithElementType != null) {
				AppendType (sb, typeWithElementType.ElementType, settings);
				
				if (typeWithElementType is PointerType) {
					sb.Append (settings.Markup ("*"));
				} 
				
				if (typeWithElementType is ArrayType) {
					sb.Append (settings.Markup ("["));
					sb.Append (settings.Markup (new string (',', ((ArrayType)type).Dimensions - 1)));
					sb.Append (settings.Markup ("]"));
				}
				return;
			}
			
			var pt = type as ParameterizedType;
			if (pt != null) {
				if (pt.Name == "Nullable" && pt.Namespace == "System" && pt.TypeParameterCount == 1) {
					AppendType (sb, pt.TypeArguments [0], settings);
					sb.Append (settings.Markup ("?"));
					return;
				}
				sb.Append (pt.Name);
				if (pt.TypeParameterCount > 0) {
					sb.Append (settings.Markup ("<"));
					for (int i = 0; i < pt.TypeParameterCount; i++) {
						if (i > 0)
							sb.Append (settings.Markup (", "));
						AppendType (sb, pt.TypeArguments [i], settings);
					}
					sb.Append (settings.Markup (">"));
				}
//.........这里部分代码省略.........

		void AppendParameterList (StringBuilder result, OutputSettings settings, IEnumerable<IParameter> parameterList)
		{
			if (parameterList == null)
				return;
			
			bool first = true;
			foreach (var parameter in parameterList) {
				if (!first)
					result.Append (settings.Markup (", "));
				AppendParameter (settings, result, parameter);
				first = false;
			}
		}

        protected override string GetFieldString(IField field, OutputSettings settings)
        {
            var result = new StringBuilder ();

            if (settings.IncludeModifiers)
                AppendModifiers (result, settings, field);

            result.Append (settings.EmitKeyword ("Field"));
            result.Append (settings.EmitName (field, field.Name));

            if (settings.IncludeReturnType) {
                result.Append (settings.Markup (" : "));
                result.Append (GetTypeReferenceString (field.ReturnType, settings));
            }
            return result.ToString ();
        }

		protected override string GetFieldString (IField field, OutputSettings settings)
		{
			if (field == null)
				return "";
			var result = new StringBuilder ();
			bool isEnum = field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum;
			AppendModifiers (result, settings, field);
			
			if (!settings.CompletionListFomat && settings.IncludeReturnType && !isEnum) {
				result.Append (GetTypeReferenceString (field.ReturnType, settings));
				result.Append (settings.Markup (" "));
			}
			
			if (!settings.IncludeReturnType && settings.UseFullName) {
				result.Append (GetTypeReferenceString (field.DeclaringTypeDefinition, settings));
				result.Append (settings.Markup ("."));
			}
			result.Append (settings.EmitName (field, FilterName (Format (field.Name))));
			
			if (settings.CompletionListFomat && settings.IncludeReturnType && !isEnum) {
				result.Append (settings.Markup (" : "));
				result.Append (GetTypeReferenceString (field.ReturnType, settings));
			}
			return result.ToString ();
		}

		protected override string GetIndexerString (IProperty property, OutputSettings settings)
		{
			if (property == null)
				return "";
			var result = new StringBuilder ();
			
			AppendModifiers (result, settings, property);
			
			if (settings.IncludeReturnType) {
				result.Append (GetTypeReferenceString (property.ReturnType, settings));
				result.Append (settings.Markup (" "));
			}
			
			if (!settings.IncludeReturnType && settings.UseFullName) {
				result.Append (GetTypeReferenceString (property.DeclaringTypeDefinition, new OutputSettings (OutputFlags.UseFullName)));
				result.Append (settings.Markup ("."));
			}
			
			AppendExplicitInterfaces (result, property, settings);
			
			result.Append (settings.EmitName (property, Format ("this")));
			
			if (settings.IncludeParameters && property.Getter.Parameters.Count > 0) {
				result.Append (settings.Markup ("["));
				AppendParameterList (result, settings, property.Getter.Parameters);
				result.Append (settings.Markup ("]"));
			}
			if (settings.IncludeAccessor) {
				result.Append (settings.Markup (" {"));
				if (property.CanGet)
					result.Append (settings.Markup (" get;"));
				if (property.CanSet)
					result.Append (settings.Markup (" set;"));
				result.Append (settings.Markup (" }"));
			}
			return result.ToString ();
		}

        protected override string GetConstructorString(IMethod method, OutputSettings settings)
        {
            var result = new StringBuilder ();

            if (settings.IncludeModifiers)
                AppendModifiers (result, settings, method);

            result.Append (settings.EmitKeyword ("Constructor"));
            result.Append (settings.EmitName (method, method.DeclaringType.Name));

            if (settings.IncludeParameters) {
                result.Append (settings.Markup ("("));
                bool first = true;
                foreach (var parameter in method.Parameters) {
                    if (!first)
                        result.Append (settings.Markup (", "));
                    result.Append (GetParameterString (method, parameter, settings));
                    first = false;
                }
                result.Append (settings.Markup (")"));
            }
            return result.ToString ();
        }

        protected override string GetIndexerString(IProperty property, OutputSettings settings)
        {
            if(property == null)
                return "";

            return settings.Markup(property.Name);
        }

 protected override string GetPropertyString(IProperty property, OutputSettings settings)
 {
     var result = new StringBuilder ();
     if (settings.IncludeModifiers)
         AppendModifiers (result, settings, property);
     result.Append (settings.EmitKeyword ("Property"));
     result.Append (settings.EmitName (property, property.Name));
     if (settings.IncludeReturnType) {
         result.Append (settings.Markup (" : "));
         result.Append (GetTypeReferenceString (property.ReturnType, settings));
     }
     return result.ToString ();
 }

        protected override string GetTypeString(IType t, OutputSettings settings)
        {
            ITypeDefinition type = t.GetDefinition ();
            var result = new StringBuilder ();
            if (settings.IncludeModifiers)
                AppendModifiers (result, settings, type);
            if (settings.IncludeKeywords)
                result.Append (settings.EmitKeyword (GetString (type.Kind)));

            result.Append (settings.EmitName (type, settings.UseFullName ? type.FullName : type.Name));

            int parameterCount = type.TypeParameters.Count;

            if (settings.IncludeGenerics && parameterCount > 0) {
                result.Append (settings.Markup ("<"));
                if (!settings.HideGenericParameterNames) {
                    for (int i = 0; i < parameterCount; i++) {
                        if (i > 0)
                            result.Append (settings.Markup (", "));
                        result.Append (type.TypeParameters [i].Name);
                    }
                }
                result.Append (settings.Markup (">"));
            }

            if (settings.IncludeBaseTypes && type.DirectBaseTypes.Any ()) {
                result.Append (settings.Markup (" : "));
                bool first = true;
                foreach (var baseType in type.DirectBaseTypes) {
                    if (baseType.Equals (type.Compilation.FindType (KnownTypeCode.Object)))
                        continue;
                    if (!first)
                        result.Append (settings.Markup (", "));
                    first = false;
                    result.Append (GetTypeReferenceString (baseType, settings));
                }

            }
            return result.ToString ();
        }

 protected override string GetParameterString(IParameterizedMember member, IParameter parameter, OutputSettings settings)
 {
     var result = new StringBuilder ();
     if (settings.IncludeParameterName) {
         result.Append (Format (parameter.Name));
         if (settings.IncludeReturnType) {
             result.Append (settings.Markup (" : "));
             result.Append (GetTypeReferenceString (parameter.Type, settings));
         }
     } else {
         result.Append (GetTypeReferenceString (parameter.Type, settings));
     }
     if (parameter.IsRef || parameter.IsOut)
         result.Append (settings.Markup ("&"));
     return result.ToString ();
 }

        protected override string GetOperatorString(IMethod method, OutputSettings settings)
        {
            var result = new StringBuilder ();

            if (settings.IncludeModifiers)
                AppendModifiers (result, settings, method);

            result.Append (settings.EmitKeyword ("Operator"));
            result.Append (settings.EmitName (method, settings.UseFullName ? method.FullName : method.Name));

            if (settings.IncludeParameters) {
                result.Append (settings.Markup ("("));
                bool first = true;
                foreach (var parameter in method.Parameters) {
                    if (!first)
                        result.Append (settings.Markup (", "));
                    result.Append (GetParameterString (method, parameter, settings));
                    first = false;
                }
                result.Append (settings.Markup (")"));
            }

            if (settings.IncludeReturnType) {
                result.Append (settings.Markup (" : "));
                result.Append (GetTypeReferenceString (method.ReturnType, settings));
            }
            return result.ToString ();
        }

        protected override string GetIndexerString(IProperty property, OutputSettings settings)
        {
            var result = new StringBuilder ();
            if (settings.IncludeModifiers)
                AppendModifiers (result, settings, property);
            result.Append (settings.EmitKeyword ("Indexer"));
            result.Append (settings.EmitName (property, property.Name));

            if (settings.IncludeParameters && property.Parameters.Count > 0) {
                result.Append (settings.Markup ("("));
                bool first = true;
                foreach (var parameter in property.Parameters) {
                    if (!first)
                        result.Append (settings.Markup (", "));
                    result.Append (GetParameterString (property, parameter, settings));
                    first = false;
                }
                result.Append (settings.Markup (")"));
            }
            if (settings.IncludeReturnType) {
                result.Append (settings.Markup (" : "));
                result.Append (GetTypeReferenceString (property.ReturnType, settings));
            }
            return result.ToString ();
        }

		string InternalGetMethodString (IMethod method, OutputSettings settings, string methodName, bool getReturnType)
		{
			if (method == null)
				return "";
			var result = new StringBuilder ();
			AppendModifiers (result, settings, method);
			if (!settings.CompletionListFomat && settings.IncludeReturnType && getReturnType) {
				result.Append (GetTypeReferenceString (method.ReturnType, settings));
				result.Append (settings.Markup (" "));
			}
			
			if (!settings.IncludeReturnType && settings.UseFullName) {
				result.Append (GetTypeReferenceString (method.DeclaringTypeDefinition, new OutputSettings (OutputFlags.UseFullName)));
				result.Append (settings.Markup ("."));
			}
			AppendExplicitInterfaces (result, method, settings);
			if (method.EntityType == EntityType.Operator) {
				result.Append ("operator ");
				result.Append (settings.Markup (GetOperator (methodName)));
			} else {
				result.Append (methodName);
			}
			
			if (settings.IncludeGenerics) {
				if (method.TypeParameters.Count > 0) {
					result.Append (settings.Markup ("<"));
					for (int i = 0; i < method.TypeParameters.Count; i++) {
						if (i > 0)
							result.Append (settings.Markup (settings.HideGenericParameterNames ? "," : ", "));
						if (!settings.HideGenericParameterNames) {
							AppendVariance (result, method.TypeParameters [i].Variance);
							result.Append (NetToCSharpTypeName (method.TypeParameters [i].Name));
						}
					}
					result.Append (settings.Markup (">"));
				}
			}
			
			if (settings.IncludeParameters) {
//			CSharpFormattingPolicy policy = GetPolicy (settings);
//			if (policy.BeforeMethodCallParentheses)
//				result.Append (settings.Markup (" "));
				result.Append (settings.Markup ("("));
				AppendParameterList (result, settings, method.Parameters);
				result.Append (settings.Markup (")"));
			}
			
			if (settings.CompletionListFomat && settings.IncludeReturnType && getReturnType) {
				result.Append (settings.Markup (" : "));
				result.Append (GetTypeReferenceString (method.ReturnType, settings));
			}
			
//		OutputConstraints (result, settings, method.TypeParameters);
			
			return result.ToString ();			
		}