C# TypeDeclaration.ToString方法代码示例

        private void handle(TypeDeclaration type, DirectoryInfo projectFolder)
        {
            if (type.ClassType != ClassType.Enum)
                return;

            Dictionary<String, String> textDict = new Dictionary<string, string>();
            foreach (AttributeSection attribute in type.Attributes)
            {
                String attributeText = attribute.ToString();
                Match attributeNameMatch = getAttrubuteNameRegex.Match(attribute.ToString());

                Group attributeNameGroup = attributeNameMatch.Groups["name"];
                if (!attributeNameGroup.Success || attributeNameGroup.Value != "TextResource")
                    continue;

                foreach (Match match in regex.Matches(type.ToString()))
                {
                    Group keyGroup = match.Groups["key"];
                    Group valueGroup = match.Groups["value"];
                    if (!keyGroup.Success || !valueGroup.Success)
                        continue;
                    String key = keyGroup.Value.Trim();
                    String value = valueGroup.Value.Trim();
                    textDict.Add(key, value);
                }
            }
            if (textDict.Count == 0)
                return;

            TypeDeclaration currentType = type;
            String typeFullName = null;
            while (true)
            {
                if (typeFullName == null)
                    typeFullName = type.Name;
                else
                    typeFullName = String.Format("{0}+{1}", currentType.Name, typeFullName);
                if (currentType.Parent is TypeDeclaration)
                {
                    currentType = (TypeDeclaration)currentType.Parent;
                    continue;
                }
                else if (currentType.Parent is NamespaceDeclaration)
                {
                    NamespaceDeclaration namesp = (NamespaceDeclaration)currentType.Parent;
                    typeFullName = String.Format("{0}.{1}", namesp.FullName, typeFullName);
                    break;
                }
                else
                    throw new ApplicationException("Type's parent unknown!");
            }
            handle(typeFullName, textDict, projectFolder);
        }

        InterfaceRenderInformation renderInterface(TypeDeclaration interfaceDecl)
        {
            var ret = new InterfaceRenderInformation();

            ret.isRoutableViewModel = interfaceDecl.BaseTypes
                .OfType<SimpleType>()
                .Any(x => x.Identifier == "IRoutableViewModel") ? ret : null;

            ret.definition = "public " + chompedString(interfaceDecl.ToString().Replace("[Once]", ""));
            ret.interfaceName = chompedString(interfaceDecl.Name);
            ret.implClassName = ret.interfaceName.Substring(1); // Skip the 'I'

            ret.properties = interfaceDecl.Children
                .Where(x => x is PropertyDeclaration || x is MethodDeclaration)
                .Select(renderPropertyDeclaration)
                .ToArray();

            ret.onceProperties = ret.properties
                .Where(x => x.onceProp != null)
                .Select(x => x.onceProp)
                .ToArray();

            return ret;
        }

        public static TypeCode Set(TypeDeclaration typedecl, CSharpAstResolver resolver)
        {
            var ns = typedecl.Parent as NamespaceDeclaration;
            var nsName = ns == null ? "" : ns.FullName;
            var name = typedecl.Name;

            var usings =
                resolver.RootNode.Descendants.
                OfType<UsingDeclaration> ().
                Select (x => x.ToString ().Trim ()).
                ToList ();

            var code = typedecl.ToString ();

            var deps = new List<String> ();
            foreach (var d in typedecl.Descendants.OfType<SimpleType> ()) {
                deps.Add (d.Identifier);
            }

            return Set (name, usings, code, deps, nsName);
        }

		private static void WriteTypeDeclaration(TypeDeclaration value, TextWriter writer)
		{
			writer.Write(value.ToString());
		}