C# INamedTypeSymbol.ToString方法代码示例

 public static CompleterResult Generate(SemanticModel model, INamedTypeSymbol type)
 {
     //TODO error or skip if null
     var cctor = type.StaticConstructor();
     if(cctor == null || cctor.IsImplicitlyDeclared)
         return default(string);
     var syntax = (ConstructorDeclarationSyntax)cctor.Node();
     var properties = syntax.Body.Statements
         .Select(statement => {
             return (statement as ExpressionStatementSyntax)?.Expression as InvocationExpressionSyntax;
         })
         .Where(invocation => invocation != null)
         .Select(invocation => LinqExtensions.Unfold(
                 invocation,
                 x => (x.Expression as MemberAccessExpressionSyntax)?.Expression as InvocationExpressionSyntax
             )
             .ToArray()
         )
         .Where(chain => {
             var lastMemberAccess = chain.Last().Expression as MemberAccessExpressionSyntax;
             return (lastMemberAccess?.Expression as GenericNameSyntax)?.Identifier.ValueText == "DependencyPropertyRegistrator" //TODO check real type from model
                 && lastMemberAccess?.Name.Identifier.ValueText == "New";
         })
         .Select(chain => GenerateProperties(model, type, chain));
     return properties
         .AggregateEither(
             errors => errors.SelectMany(x => x).ToImmutableArray(),
             values => {
                 var conctenated = values.ConcatStringsWithNewLines();
                 if(string.IsNullOrEmpty(conctenated))
                     return null;
                 return
     [email protected]"partial class {type.ToString().Split('.').Last()} {{
     {conctenated.AddTabs(1)}
     }}";
             });
 }

        /// <summary>
        /// Gets the set of diagnostic descriptors that can be reported by the analyzer.
        /// </summary>
        /// <param name="diagnosticAnalyzer">A symbol of the analyzer type.</param>
        /// <returns>The set of diagnostic descriptors that can be reported by the analyzer.</returns>
        private ImmutableArray<DiagnosticDescriptor> GetDescriptorInstances(INamedTypeSymbol diagnosticAnalyzer)
        {
            var analyzer = (DiagnosticAnalyzer)Activator.CreateInstance(this.analyzerAssembly.GetType(diagnosticAnalyzer.ToString()));

            return analyzer.SupportedDiagnostics;
        }

        private IEnumerable<DiagnosticDescriptor> GetDescriptor(INamedTypeSymbol classSymbol)
        {
            var analyzer = (DiagnosticAnalyzer)Activator.CreateInstance(this.analyzerAssembly.GetType(classSymbol.ToString()));

            // This currently only supports one diagnostic for each analyzer.
            return analyzer.SupportedDiagnostics;
        }

        /// <summary>
        ///     Builds models representing methods of the factories.
        /// </summary>
        /// <param name="concreteClassSymbol">
        ///     Represents the concrete class.
        /// </param>
        /// <param name="fields">
        ///     Fields available in the factory.
        /// </param>
        /// <param name="injectedParameters">
        ///     The injected parameters in the factory.
        /// </param>
        /// <param name="factoryMethods">
        ///     The factory methods retrieved with Roslyn.
        /// </param>
        /// <param name="factoryInterfaceName">
        ///     The interface name of the factory.
        /// </param>
        /// <returns>
        ///     Models representing the factory methods.
        /// </returns>
        public IEnumerable<Method> Build(INamedTypeSymbol concreteClassSymbol,
                                         IEnumerable<Field> fields,
                                         IParameterSymbol[] injectedParameters,
                                         IMethodSymbol[] factoryMethods,
                                         string factoryInterfaceName)
        {
            if (!factoryMethods.Any())
            {
                return Enumerable.Empty<Method>();
            }

            fields = fields as Field[] ?? fields.ToArray();
            var methods = new List<Method>();

            // ReSharper disable once LoopCanBeConvertedToQuery
            foreach (var factoryMethod in factoryMethods)
            {
                var constructor = GetConstructorFromFactoryMethod(factoryMethod, concreteClassSymbol);
                var factoryMethodParameters = factoryMethod.Parameters;

                var arguments = this.argumentsBuilderService.BuildMethodArgument(factoryMethodParameters)
                                    .ToArray();
                var constructorArguments = this.BuildConstructorParameters(constructor, arguments, fields, injectedParameters, factoryInterfaceName);
                var genericArguments = this.genericTypeBuilderService.Build(factoryMethod.TypeParameters);

                if (this.writeXmlDoc)
                {
                    var xmlComments = BuildXmlDoc(factoryMethod);
                    methods.Add(new Method("Create", factoryMethod.ReturnType.ToString(), concreteClassSymbol.ToString(), arguments, constructorArguments, genericArguments, xmlComments));
                }
                else
                {
                    methods.Add(new Method("Create", factoryMethod.ReturnType.ToString(), concreteClassSymbol.ToString(), arguments, constructorArguments, genericArguments, string.Empty));
                }
            }

            return methods;
        }

		private static bool IsDerivedFromClass(INamedTypeSymbol classSymbol, string fullNameOfClassToTestFor)
		{
			if (classSymbol == null)
				throw new ArgumentNullException(nameof(classSymbol));
			if (string.IsNullOrWhiteSpace(fullNameOfClassToTestFor))
				throw new ArgumentNullException($"No {nameof(fullNameOfClassToTestFor)} specified");

			if (fullNameOfClassToTestFor.Contains("`"))
			{
				var classNameSegments = fullNameOfClassToTestFor.Split('`');
				if (classNameSegments.Length > 2)
					throw new Exception("Class name contains \"`\", which suggest arity details but it appears multiple times (only expected once, to be followed by a numeric value)");
				int arity;
				if (!int.TryParse(classNameSegments[1], out arity))
					throw new Exception("Class name contains \"`\", which suggest arity details but second segment is non-numeric");
				if (classSymbol.IsGenericType && ((uint)classSymbol.TypeArguments.Count() == arity))
				{
					if (classSymbol.ToString().Split('<').First() == classNameSegments[0])
						return true;
				}
			}
			else
			{
				if (!classSymbol.IsGenericType)
				{
					if (classSymbol.ToString() == fullNameOfClassToTestFor)
						return true;
				}
			}

			return (classSymbol.BaseType != null) && IsDerivedFromClass(classSymbol.BaseType, fullNameOfClassToTestFor);
		}