C# TypeSyntax.ToString方法代码示例

        public static string GetTrackerClassName(TypeSyntax type)
        {
            // NOTE: it's naive approach because we don't know semantic type information here.
            var genericType = type as GenericNameSyntax;
            if (genericType == null)
            {
                if (type.ToString().StartsWith("Trackable"))
                {
                    return $"TrackablePocoTracker<I{type.ToString().Substring(9)}>";
                }
            }
            else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(),
                                                             "TrackableData.TrackableDictionary"))
            {
                return $"TrackableDictionaryTracker{genericType.TypeArgumentList}";
            }
            else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(),
                                                             "TrackableData.TrackableSet"))
            {
                return $"TrackableSetTracker{genericType.TypeArgumentList}";
            }
            else if (CodeAnalaysisExtensions.CompareTypeName(genericType.Identifier.ToString(),
                                                             "TrackableData.TrackableList"))
            {
                return $"TrackableListTracker{genericType.TypeArgumentList}";
            }

            throw new Exception("Cannot resolve tracker class of " + type);
        }

 public static bool IsTrackableType(TypeSyntax type)
 {
     // NOTE: it's naive approach because we don't know semantic type information here.
     var parts = type.ToString().Split('.');
     var typeName = parts[parts.Length - 1];
     return typeName.StartsWith("Trackable");
 }

        public static string GetFieldVariableName(TypeSyntax type, bool underscore)
        {
            var name = type.ToString();
            if (name.StartsWith("I"))
                name = name.Substring(1);

            var firstChara = name[0];
            if (Char.IsUpper(firstChara))
            {
                name = firstChara.ToString().ToLower() + name.Substring(1);
            }
            else
            {
                name += 1;
            }

            return name;
        }

 private static string ResolveLType(TypeSyntax node)
 {
     var gensyn = node as GenericNameSyntax;
     if (null != gensyn) return gensyn.Identifier.ToString();
     else return node.ToString();
 }

        /// <remarks>
        /// Keep in sync with <see cref="M:SemanticModel.GetSpeculativelyBoundExpression()"/>.
        /// </remarks>
        private TypeSymbol BindCrefParameterOrReturnType(TypeSyntax typeSyntax, MemberCrefSyntax memberCrefSyntax, DiagnosticBag diagnostics)
        {
            DiagnosticBag unusedDiagnostics = DiagnosticBag.GetInstance(); // Examined, but not reported.

            // After much deliberation, we eventually decided to suppress lookup of inherited members within
            // crefs, in order to match dev11's behavior (Changeset #829014).  Unfortunately, it turns out
            // that dev11 does not suppress these members when performing lookup within parameter and return
            // types, within crefs (DevDiv #586815, #598371).
            Debug.Assert(InCrefButNotParameterOrReturnType);
            Binder parameterOrReturnTypeBinder = this.WithAdditionalFlags(BinderFlags.CrefParameterOrReturnType);

            // It would be nice to pull this binder out of the factory so we wouldn't have to worry about them getting out
            // of sync, but this code is also used for included crefs, which don't have BinderFactories.
            // As a compromise, we'll assert that the binding locations match in scenarios where we can go through the factory.
            Debug.Assert(!this.Compilation.ContainsSyntaxTree(typeSyntax.SyntaxTree) ||
                this.Compilation.GetBinderFactory(typeSyntax.SyntaxTree).GetBinder(typeSyntax).Flags ==
                (parameterOrReturnTypeBinder.Flags & ~BinderFlags.SemanticModel));

            TypeSymbol type = parameterOrReturnTypeBinder.BindType(typeSyntax, unusedDiagnostics);

            if (unusedDiagnostics.HasAnyErrors())
            {
                if (HasNonObsoleteError(unusedDiagnostics))
                {
                    ErrorCode code = typeSyntax.Parent.Kind == SyntaxKind.ConversionOperatorMemberCref
                        ? ErrorCode.WRN_BadXMLRefReturnType
                        : ErrorCode.WRN_BadXMLRefParamType;
                    CrefSyntax crefSyntax = GetRootCrefSyntax(memberCrefSyntax);
                    diagnostics.Add(code, typeSyntax.Location, typeSyntax.ToString(), crefSyntax.ToString());
                }
            }
            else
            {
                Debug.Assert(type.TypeKind != TypeKind.Error || typeSyntax.ContainsDiagnostics || !typeSyntax.SyntaxTree.ReportDocumentationCommentDiagnostics(), "Why wasn't there a diagnostic?");
            }

            unusedDiagnostics.Free();

            return type;
        }

        private static string GetTypeScriptEquivalentType(TypeSyntax field)
        {
            var type = "";
            switch (field.ToString().ToLower())
            {
                case "int":
                case "float":
                case "small":
                case "bigint":
                    type = "number";
                    break;
                default:
                    type = field.ToString();
                    break;
            }

            return type;
        }

        private string GetMappedType(TypeSyntax type)
        {
            if (type.ToString() == "void")
                return "void";

            if (type.ToString().EndsWith("Exception"))
                return type.ToString();

            return type.ToString().StartsWith("int") ? "number" : "string";
        }

 // The "target = new Class1()" portion of "Class1 target = new Class1();"
 private VariableDeclarationSyntax BuildVariableDeclaration(TypeSyntax variableType, string variableName)
 {
     return SyntaxFactory.VariableDeclaration(variableType,
             SyntaxFactory.SingletonSeparatedList<VariableDeclaratorSyntax>(
                 SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(SyntaxFactory.TriviaList(), variableName, SyntaxFactory.TriviaList(SyntaxFactory.Space)))
                     .WithInitializer(
                         SyntaxFactory.EqualsValueClause(
                             SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName(variableType.ToString()))
                             .WithNewKeyword(SyntaxFactory.Token(SyntaxFactory.TriviaList(SyntaxFactory.Space), SyntaxKind.NewKeyword, SyntaxFactory.TriviaList(SyntaxFactory.Space)))
                             .WithArgumentList(SyntaxFactory.ArgumentList())
                         )
                     )
             )
     );
 }

 private string GetName(TypeSyntax name)
 {
     return (name as SimpleNameSyntax).Identifier.ToString() ?? name.ToString();
 }

        private string GetFullReturnType(TypeSyntax returnType)
        {
            var fullReturnType = returnType.ToString();
            var node = returnType.DescendantNodes().OfType<IdentifierNameSyntax>().FirstOrDefault();
            Document cl = null;

            var systemTypes = new List<string>()
            {
                "Guid",
                "Guid?"
            };

            if (node != null && systemTypes.All(x => x != node.Identifier.ToString() && x != returnType.ToString()))
            {
                var nameSpace = SymbolFinder.FindDeclarationsAsync(_project, node.Identifier.ValueText, ignoreCase: false).Result.Last().ContainingNamespace.ToString();

                fullReturnType = fullReturnType.Replace(node.Identifier.ToString(), nameSpace + "." + node.Identifier);
            }

            return fullReturnType;
        }

 public TypeInspector(TypeSyntax typeSyntax)
 {
     ShortName = typeSyntax.ToString();
 }