private ConfigLoadResult(AnalyzerConfigState configState, AnalyzerConfigBuilder configBuilder,
IAnalyzerConfig config, Exception configException)
{
ConfigState = configState;
ConfigBuilder = configBuilder;
Config = config;
ConfigException = configException;
}
public DependencyAnalyzer(IAnalyzerConfig config,
ITypeDependencyEnumerator typeDependencyEnumerator,
MessageHandler traceMessageHandler)
{
_config = config ?? throw new ArgumentNullException(nameof(config));
_typeDependencyEnumerator = typeDependencyEnumerator ?? throw new ArgumentNullException(nameof(typeDependencyEnumerator));
_traceMessageHandler = traceMessageHandler;
_typeDependencyValidator = new CachingTypeDependencyValidator(_config, _traceMessageHandler);
}
private static IDependencyAnalyzer CreateAnalyzer(IAnalyzerConfig config, bool useOutOfProcessAnalyzer)
{
var typeDependencyEnumerator = new Roslyn2TypeDependencyEnumerator(LogTraceToConsole);
var analyzerFactory = new DependencyAnalyzerFactory(config, LogTraceToConsole);
return(useOutOfProcessAnalyzer
? analyzerFactory.CreateOutOfProcess(ServiceAddressProvider.ServiceAddress)
: analyzerFactory.CreateInProcess(typeDependencyEnumerator));
}
private void UpdateConfig()
{
var oldConfig = _config;
_config = _configProvider.Config;
if (oldConfig == _config)
{
return;
}
UpdateAnalyzer();
}
private void UpdateConfig()
{
var oldConfig = _config;
_config = ConfigProvider.Config;
if (oldConfig == _config)
{
return;
}
_typeDependencyValidator = CreateTypeDependencyValidator();
}
private void UpdateConfig()
{
var oldConfig = _config;
_config = ConfigProvider.Config;
if (oldConfig == _config)
{
return;
}
_typeDependencyValidator = CreateTypeDependencyValidator();
_sourcePathExclusionGlobs = _config.SourcePathExclusionPatterns.Select(Glob.Parse).ToArray();
}
public AnalyzerMessageBase[] AnalyzeProject(IAnalyzerConfig config, string[] sourcePaths, string[] referencedAssemblyPaths)
{
var resultBuilder = new AnalyzeProjectResultBuilder();
var dependencyAnalyzer = _dependencyAnalyzerFactory.Create(config);
var illegalDependencies = dependencyAnalyzer.AnalyzeProject(sourcePaths, referencedAssemblyPaths);
foreach (var illegalDependency in illegalDependencies)
{
resultBuilder.AddIllegalDependency(illegalDependency);
}
return(resultBuilder.ToArray());
}
public AnalyzerMessageBase[] AnalyzeProject(IAnalyzerConfig config, string[] sourcePaths, string[] referencedAssemblyPaths)
{
var traceMessageBuffer = new List <string>();
var typeDependencyValidator = new CachingTypeDependencyValidator(config);
var typeDependencyEnumerator = new Roslyn2TypeDependencyEnumerator(i => traceMessageBuffer.Add(i));
var typeDependencies = typeDependencyEnumerator.GetTypeDependencies(sourcePaths, referencedAssemblyPaths);
var illegalDependencies = typeDependencies.Where(i => !typeDependencyValidator.IsAllowedDependency(i)).Take(config.MaxIssueCount);
traceMessageBuffer.Add(GetCacheStatisticsMessage(typeDependencyValidator));
var traceMessages = traceMessageBuffer.Select(i => new TraceMessage(i));
var illegalDependencyMessages = illegalDependencies.Select(i => new IllegalDependencyMessage(i));
return(illegalDependencyMessages.OfType <AnalyzerMessageBase>().Concat(traceMessages).ToArray());
}
public AnalyzerMessageBase[] AnalyzeProject(IAnalyzerConfig config, string[] sourcePaths, string[] referencedAssemblyPaths)
{
var resultBuilder = new AnalyzeProjectResultBuilder();
var typeDependencyEnumerator = GetTypeDependencyEnumerator(resultBuilder.AddTrace);
var dependencyAnalyzer = new DependencyAnalyzer(config, typeDependencyEnumerator, resultBuilder.AddTrace);
var illegalDependencies = dependencyAnalyzer.AnalyzeProject(sourcePaths, referencedAssemblyPaths);
foreach (var illegalDependency in illegalDependencies)
{
resultBuilder.AddIllegalDependency(illegalDependency);
}
resultBuilder.AddCacheStatistics(dependencyAnalyzer.HitCount, dependencyAnalyzer.MissCount, dependencyAnalyzer.EfficiencyPercent);
return(resultBuilder.ToArray());
}
public IRemoteMessage[] AnalyzeProject(IAnalyzerConfig config, string[] sourcePaths, string[] referencedAssemblyPaths)
{
var messageBuffer = new List <IRemoteMessage>();
var typeDependencyEnumerator = GetTypeDependencyEnumerator(WrapIntoTraceMessage(messageBuffer));
var typeDependencyValidator = new CachingTypeDependencyValidator(config, WrapIntoTraceMessage(messageBuffer));
var illegalDependencyMessages = typeDependencyEnumerator
.GetTypeDependencies(sourcePaths, referencedAssemblyPaths)
.Where(i => !typeDependencyValidator.IsAllowedDependency(i))
.Take(config.MaxIssueCount + 1)
.Select(i => new RemoteIllegalDependencyMessage(i));
messageBuffer.AddRange(illegalDependencyMessages);
WrapIntoTraceMessage(messageBuffer)(GetCacheStatisticsMessage(typeDependencyValidator));
return(messageBuffer.ToArray());
}
public DependencyAnalyzerFactory(IAnalyzerConfig config, MessageHandler traceMessageHandler)
{
_config = config;
_traceMessageHandler = traceMessageHandler;
}
public AnalyzerMessageBase[] AnalyzeProject(IAnalyzerConfig config, string[] sourcePaths, string[] referencedAssemblyPaths)
{
return(PerformCallWithRetries(i => i.AnalyzeProject(config, sourcePaths, referencedAssemblyPaths)));
}
public IDependencyAnalyzer Create(IAnalyzerConfig config)
{
return(new DependencyAnalyzer(config, _typeDependencyEnumerator, _traceMessageHandler));
}
public RemoteDependencyAnalyzerClient(IAnalyzerConfig config, string serviceAddress, MessageHandler traceMessageHandler)
{
_config = config ?? throw new ArgumentNullException(nameof(config));
_serviceAddress = serviceAddress ?? throw new ArgumentNullException(nameof(serviceAddress));
_traceMessageHandler = traceMessageHandler;
}
