ArchiMetrics.Analysis.CodeMetricsCalculator.Calculate C# (CSharp) Метод

		public async Task<IEnumerable<INamespaceMetric>> Calculate(IEnumerable<SyntaxTree> syntaxTrees, params Assembly[] references)
		{
			var trees = syntaxTrees.AsArray();
			var declarations = _syntaxCollector.GetDeclarations(trees);
			var statementMembers = declarations.Statements.Select(s =>
				s is StatementSyntax
				? SyntaxFactory.MethodDeclaration(
					SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)),
					Guid.NewGuid().ToString("N"))
					.WithBody(SyntaxFactory.Block((StatementSyntax)s))
					: s);
			var members = declarations.MemberDeclarations.Concat(statementMembers).AsArray();
			var anonClass = members.Any()
								? new[]
                                  {
                                      SyntaxFactory.ClassDeclaration(
                                          "UnnamedClass")
                                          .WithModifiers(
                                              SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)))
                                          .WithMembers(SyntaxFactory.List(members))
                                  }
								: new TypeDeclarationSyntax[0];
			var array = declarations.TypeDeclarations
				.Concat(anonClass)
				.Cast<MemberDeclarationSyntax>()
				.AsArray();
			var anonNs = array.Any()
				? new[]
                          {
                              SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName("Unnamed"))
                                  .WithMembers(SyntaxFactory.List(array))
                          }
				: new NamespaceDeclarationSyntax[0];
			var namespaceDeclarations = declarations
				.NamespaceDeclarations
				.Concat(anonNs)
				.Select(x => new NamespaceDeclarationSyntaxInfo
				{
					Name = x.GetName(x),
					Syntax = x
				})
				.GroupBy(x => x.Name)
				.Select(g => new NamespaceDeclaration
				{
					Name = g.Key,
					SyntaxNodes = g.AsArray()
				})
				.AsArray();

			var metadataReferences =
				(references.Any() ? references : new[] { typeof(object).Assembly }).Select(a => MetadataReference.CreateFromFile(a.Location)).ToArray();
			var commonCompilation = CSharpCompilation.Create("x", syntaxTrees: trees, references: metadataReferences);
			var namespaceMetrics = await CalculateNamespaceMetrics(namespaceDeclarations, commonCompilation, null).ConfigureAwait(false);
			return namespaceMetrics;
		}

 async void Analyzeblock(CodeBlockAnalysisContext obj)
 {
     var metricsCalculator = new CodeMetricsCalculator();
     var metrics = await metricsCalculator.Calculate(new List<SyntaxTree> { CSharpSyntaxTree.ParseText(obj.CodeBlock.ToString()) });
     var functionMetric = metrics.ElementAt(0).TypeMetrics.ElementAt(0).MemberMetrics.ElementAt(0);
     //var settings = SettingsHelper.GetSettings(obj.Options);
     var settings = new Settings();
     CheckComplexity(obj, functionMetric.CyclomaticComplexity, settings.MethodSettings);
     CheckNumberOfParameters(obj, functionMetric.NumberOfParameters, settings.MethodSettings);
     CheckLinesOfCode(obj, functionMetric.LinesOfCode, settings.MethodSettings);
 }