private static Namespaces GetNamespaces(NamespaceMetrics metrics)
{
Namespaces @namespace = new Namespaces();
@namespace.AddRange(MetricsReportBuilder.GetNamespaceResults(metrics));
return(@namespace);
}
private static IEnumerable <string> CalculateClassCoupling(NamespaceMetrics metrics)
{
return((
from x in metrics.Results.SelectMany <NamespaceMetric, MetricResult>((NamespaceMetric x) => x.Metrics).Where <MetricResult>((MetricResult x) => x.Name == "ClassCoupling").OfType <ClassCouplingMetricResult>().SelectMany <ClassCouplingMetricResult, string>((ClassCouplingMetricResult x) => x.Types).Distinct <string>()
orderby x
select x).ToList <string>());
}
private static double CalculateMaintainabilityIndex(NamespaceMetrics metrics)
{
IEnumerable <double> list = metrics.Results.SelectMany <NamespaceMetric, MetricResult>((NamespaceMetric x) => x.Metrics).Where <MetricResult>((MetricResult x) => x.Name == "MaintainabilityIndex").Select <MetricResult, double>((MetricResult x) => (double)x.Value).ToList <double>();
if (!list.Any <double>())
{
return(100);
}
return(Math.Round(list.Sum() / (double)list.Count <double>()));
}
private int CalculateDepthOfInheritance(NamespaceMetrics metrics)
{
IEnumerable <int> nums = metrics.Results.SelectMany <NamespaceMetric, MetricResult>((NamespaceMetric x) => x.Metrics).Where <MetricResult>((MetricResult x) => x.Name == "DepthOfInheritance").Select <MetricResult, int>((MetricResult x) => (int)x.Value);
if (!nums.Any <int>())
{
return(0);
}
return(nums.Max());
}
private static IEnumerable <Namespace> GetNamespaceResults(NamespaceMetrics metrics)
{
foreach (NamespaceMetric namespaceMetric in metrics.Results)
{
Namespace @namespace = new Namespace();
@namespace.Name = namespaceMetric.Name;
Namespace namespace1 = @namespace;
if (namespaceMetric.Metrics != null)
{
namespace1.Add(MetricsReportBuilder.GetMetricsResult(namespaceMetric.Metrics));
}
namespace1.Add(MetricsReportBuilder.GetTypesResult(namespaceMetric.TypeMetrics));
yield return(namespace1);
}
}
public ProjectMetric(string name, IEnumerable <INamespaceMetric> namespaceMetrics, IEnumerable <string> referencedProjects, double relationalCohesion)
{
Name = name;
RelationalCohesion = relationalCohesion;
AssemblyDependencies = referencedProjects.AsArray();
EfferentCoupling = AssemblyDependencies.Count();
NamespaceMetrics = namespaceMetrics.AsArray();
LinesOfCode = NamespaceMetrics.Sum(x => x.LinesOfCode);
MaintainabilityIndex = LinesOfCode == 0 ? 100 : NamespaceMetrics.Sum(x => x.MaintainabilityIndex * x.LinesOfCode) / LinesOfCode;
CyclomaticComplexity = LinesOfCode == 0 ? 0 : NamespaceMetrics.Sum(x => x.CyclomaticComplexity * x.LinesOfCode) / LinesOfCode;
Dependencies = NamespaceMetrics.SelectMany(x => x.Dependencies).Where(x => x.Assembly != Name).Distinct(Comparer).AsArray();
Dependants = Dependencies.Select(x => x.Assembly)
.Distinct()
.AsArray();
AfferentCoupling = Dependants.Count();
var typeMetrics = NamespaceMetrics.SelectMany(x => x.TypeMetrics).AsArray();
Abstractness = typeMetrics.Count(x => x.IsAbstract) / (double)typeMetrics.Length;
}
public ModuleMetric Calculate(Project project)
{
Compilation compilation = ProjectExtensions.GetCompilation(project);
IModuleSymbol moduleSymbol = compilation.Assembly.Modules.FirstOrDefault <IModuleSymbol>();
NamespaceMetrics namespaceMetric = ModuleMetricsCalculator.CalculateNamespaceMetrics(project, this.IgnoreGeneratedCode);
NamespaceMetrics namespaceMetric1 = namespaceMetric;
if (namespaceMetric == null)
{
return(null);
}
IEnumerable <string> strs = ModuleMetricsCalculator.CalculateClassCoupling(namespaceMetric1);
double num = ModuleMetricsCalculator.CalculateMaintainabilityIndex(namespaceMetric1);
int num1 = ModuleMetricsCalculator.CalculateCyclomaticComplexity(namespaceMetric1);
int num2 = this.CalculateDepthOfInheritance(namespaceMetric1);
int num3 = ModuleMetricsCalculator.CalculateLinesOfCode(namespaceMetric1);
int num4 = namespaceMetric1.Results.Count <NamespaceMetric>();
int num5 = ModuleMetricsCalculator.CalculateNumberOfTypes(namespaceMetric1);
int num6 = ModuleMetricsCalculator.CalculateNumberOfMethods(namespaceMetric1);
ModuleMetric moduleMetric = new ModuleMetric();
moduleMetric.ModuleName = moduleSymbol.Name;
moduleMetric.ProjectFile = project.FilePath ?? string.Empty;
moduleMetric.AssemblyVersion = string.Empty;
moduleMetric.FileVersion = string.Empty;
moduleMetric.NamespaceMetrics = namespaceMetric1;
List <MetricResult> metricResults = new List <MetricResult>();
moduleMetric.AddMetricResult(new MetricResult()
{
Name = "MaintainabilityIndex",
Value = num
});
moduleMetric.AddMetricResult(new MetricResult
{
Name = "CyclomaticComplexity",
Value = num1
});
moduleMetric.AddMetricResult(new ClassCouplingMetricResult
{
Name = "ClassCoupling",
Value = strs.Count <string>(),
Types = strs
});
moduleMetric.AddMetricResult(new MetricResult
{
Name = "DepthOfInheritance",
Value = num2
});
moduleMetric.AddMetricResult(new MetricResult
{
Name = "LinesOfCode",
Value = num3
});
moduleMetric.AddMetricResult(new MetricResult
{
Name = "NumberOfNamespaces",
Value = num4
});
moduleMetric.AddMetricResult(new MetricResult
{
Name = "NumberOfTypes",
Value = num5
});
moduleMetric.AddMetricResult(new MetricResult
{
Name = "NumberOfMethods",
Value = num6
});
return(moduleMetric);
}
private static int CalculateNumberOfTypes(NamespaceMetrics namespaceMetrics)
{
return(namespaceMetrics.Results.Sum <NamespaceMetric>((NamespaceMetric metric) => metric.TypeMetrics.Results.Count <TypeMetric>()));
}
private static int CalculateNumberOfMethods(NamespaceMetrics namespaceMetrics)
{
return(namespaceMetrics.Results.Sum <NamespaceMetric>((NamespaceMetric namespaceMetric) => namespaceMetric.TypeMetrics.Results.Sum <TypeMetric>((TypeMetric typeMetric) => typeMetric.MemberMetrics.Results.Count <MemberMetric>())));
}
private static int CalculateLinesOfCode(NamespaceMetrics metrics)
{
return(metrics.Results.SelectMany <NamespaceMetric, MetricResult>((NamespaceMetric x) => x.Metrics).Where <MetricResult>((MetricResult x) => x.Name == "LinesOfCode").Select <MetricResult, int>((MetricResult x) => (int)x.Value).Sum());
}
private static int CalculateCyclomaticComplexity(NamespaceMetrics metrics)
{
return(metrics.Results.SelectMany <NamespaceMetric, MetricResult>((NamespaceMetric x) => x.Metrics).Where <MetricResult>((MetricResult x) => x.Name == "CyclomaticComplexity").Select <MetricResult, int>((MetricResult x) => (int)x.Value).Sum());
}
