/// <summary>
/// Execute checking up.
/// </summary>
public IEnumerable <ProjectReference> Execute(IProjectEvaluator evaluator)
{
using (var checker = ProjectCheckerType.Create(evaluator))
{
return(checker.Check());
}
}
/// <summary>
/// Check imported interfaces.
/// </summary>
/// <param name="checkerData">Used types and assemblies candidates.</param>
/// <param name="evaluator">The project evaluator.</param>
private void CheckImportedInterfaces(CheckerSharedData checkerData, IProjectEvaluator evaluator)
{
IEnumerable <TypeReference> typeReferences = evaluator.ProjectImportedTypesDefinitions
.SelectMany(item => item.GetInterfaces());
IMetadataScope forwardedFrom;
foreach (TypeReference typeRef in typeReferences)
{
try
{
TypeDefinition typeDef = typeRef.Resolve(out forwardedFrom);
checkerData.RemoveFromCandidates(forwardedFrom);
if (typeDef != null)
{
_helper.Check(typeDef, checkerData);
}
if (!checkerData.HasCandidateReferences)
{
break;
}
}
catch (Exception ex)
{
throw Error.CheckType(typeRef.AssemblyQualifiedName(),
string.Format(Resources.CleanExecutor_CheckInteropTypeException, typeRef.AssemblyQualifiedName()), ex);
}
}
}
/// <summary>
/// Dispose object.
/// </summary>
protected virtual void Dispose(bool disposing)
{
if (disposing && _evaluator != null)
{
_evaluator = null;
}
}
/// <summary>
/// Performs checking of attributes of types of assembly.
/// </summary>
/// <param name="sharedData">Used types and assemblies candidates.</param>
/// <param name="evaluator">The project evaluator.</param>
public void Check(CheckerSharedData sharedData, IProjectEvaluator evaluator)
{
foreach (TypeDefinition type in evaluator.ProjectTypesDefinitions)
{
_helper.Check(type, sharedData);
if (!sharedData.HasCandidateReferences)
{
return;
}
}
}
/// <summary>
/// Performs assembly's types checking.
/// </summary>
/// <param name="sharedData">Used types and assemblies candidates.</param>
/// <param name="evaluator">The project evaluator.</param>
public void Check(CheckerSharedData sharedData, IProjectEvaluator evaluator)
{
var query = (from reference in sharedData.CandidateReferences
join assemblyRef in evaluator.ManifestAssemblies
on reference.FullName.ToUpper() equals assemblyRef.FullName.ToUpper()
select reference).ToList();
foreach (var reference in query)
{
sharedData.RemoveFromCandidates(reference);
}
}
/// <summary>
/// Performs assembly's types checking.
/// </summary>
/// <param name="sharedData">Used types and assemblies candidates.</param>
/// <param name="evaluator">The project evaluator.</param>
public void Check(CheckerSharedData sharedData, IProjectEvaluator evaluator)
{
try
{
var reader = new ResourcesReader(evaluator);
CheckXamlDeclaredTypes(sharedData, evaluator, reader.GetXamlDeclaredTypes());
}
catch (Exception ex)
{
throw Error.CheckType(evaluator.ProjectAssembly.FullName,
Resources.BamlTypesChecker_CheckTypeException, ex);
}
}
/// <summary>
/// Check imported classes.
/// </summary>
/// <param name="checkerData">Used types and assemblies candidates.</param>
/// <param name="evaluator">The project evaluator.</param>
private void CheckImportedClasses(CheckerSharedData checkerData, IProjectEvaluator evaluator)
{
foreach (TypeDefinition typeDef in evaluator.ProjectImportedTypesDefinitions)
{
try
{
_helper.Check(typeDef, checkerData);
}
catch (Exception ex)
{
throw Error.CheckType(typeDef.AssemblyQualifiedName(),
string.Format(Resources.CleanExecutor_CheckInteropTypeException, typeDef.AssemblyQualifiedName()), ex);
}
}
}
/// <summary>
/// Performs dependent assemblies checking.
/// </summary>
/// <param name="sharedData">Used types and assemblies candidates.</param>
/// <param name="evaluator">The project evaluator.</param>
public void Check(CheckerSharedData sharedData, IProjectEvaluator evaluator)
{
foreach (AssemblyDefinition manifestAssemblyDefinition in evaluator.ManifestAssemblies)
{
try
{
CheckAssemblyTypes(manifestAssemblyDefinition, sharedData, evaluator);
if (!sharedData.HasCandidateReferences)
{
break;
}
}
catch (Exception ex)
{
ex.Data.Add("AssemblyDefinition", manifestAssemblyDefinition.FullName);
throw;
}
}
}
/// <summary>
/// Checking assembly's types which are used in BAML.
/// </summary>
/// <param name="sharedData">Used types and assemblies candidates.</param>
/// <param name="evaluator">The project evaluator.</param>
/// <param name="declaredTypes">Declared in BAML types.</param>
private void CheckXamlDeclaredTypes(CheckerSharedData sharedData, IProjectEvaluator evaluator, IEnumerable <XamlTypeDeclaration> declaredTypes)
{
var xamlTypeResolver = new XamlTypeResolver(evaluator);
foreach (var type in declaredTypes)
{
var typeDef = xamlTypeResolver.Resolve(type);
if (typeDef != null && !sharedData.IsUsedTypeExists(typeDef.AssemblyQualifiedName()))
{
_classChecher.Check(typeDef, sharedData);
_interfaceChecker.Check(typeDef, sharedData);
sharedData.RemoveFromCandidates(typeDef.Scope);
if (!sharedData.HasCandidateReferences)
{
return;
}
}
}
}
/// <summary>
/// Create a new instance of a project checker class.
/// </summary>
/// <param name="evaluator">The project evaluator.</param>
/// <returns>Returns created project checker.</returns>
public static ProjectChecker Create(IProjectEvaluator evaluator)
{
switch (evaluator.ProjectInfo.Type.ToString("D"))
{
case CSharpProjectChecker.ProjectTypeString:
return(new CSharpProjectChecker(evaluator));
case VisualBasicProjectChecker.ProjectTypeString:
return(new VisualBasicProjectChecker(evaluator));
case VisualCppCliProjectChecker.ProjectTypeString:
return(new VisualCppCliProjectChecker(evaluator));
case FSharpProjectChecker.ProjectTypeString:
return(new FSharpProjectChecker(evaluator));
default:
return(new DefaultProjectChecker(evaluator));
}
}
/// <summary>
/// Performs checking of referenced members of the specified type.
/// </summary>
/// <param name="type">The specified type.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
/// <param name="evaluator">The project evaluator.</param>
public void Check(TypeReference typeRef, CheckerSharedData sharedData, IProjectEvaluator evaluator)
{
try
{
foreach (MemberReference memberRef in GetMemberReferences(typeRef, evaluator))
{
EvaluateMemberReference(memberRef, sharedData);
if (!sharedData.HasCandidateReferences)
{
return;
}
}
}
catch (Exception ex)
{
throw Error.CheckType(typeRef.AssemblyQualifiedName(),
string.Format(Resources.MemberReferencesCheckHelper_CheckTypeException, typeRef.AssemblyQualifiedName()), ex);
}
}
/// <summary>
/// Performs assembly's types checking.
/// </summary>
/// <param name="sharedData">Used types and assemblies candidates.</param>
/// <param name="evaluator">The project evaluator.</param>
public void Check(CheckerSharedData sharedData, IProjectEvaluator evaluator)
{
if (sharedData == null)
{
throw Error.ArgumentNull("sharedData");
}
if (evaluator == null)
{
throw Error.ArgumentNull("evaluator");
}
_assemblyDefinitions.Clear();
CheckImportedClasses(sharedData, evaluator);
if (sharedData.HasCandidateReferences)
{
CheckImportedInterfaces(sharedData, evaluator);
}
}
/// <summary>
/// Inspect references.
/// </summary>
/// <param name="evaluator">The project evaluator.</param>
/// <returns>Not used project references.</returns>
public IProjectInspectResult Inspect(IProjectEvaluator evaluator)
{
try
{
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
var checkExecutor = (CheckExecutor)_executorDomain.CreateInstanceFromAndUnwrap(
Assembly.GetExecutingAssembly().Location,
CheckExecutorTypeName,
true,
BindingFlags.CreateInstance,
null,
null,
null,
null);
return(new ProjectInspectResult(evaluator.ProjectInfo, checkExecutor.Execute(evaluator)));
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve;
}
}
/// <summary>
/// Initialize a new instance of a <see cref="CSharpProjectChecker"/> class.
/// </summary>
/// <param name="evaluator">The project evaluator.</param>
public CSharpProjectChecker(IProjectEvaluator evaluator)
: base(evaluator)
{
}
/// <summary>
/// Initialize a new instance of a <see cref="VisualCppCliProjectChecker"/> class.
/// </summary>
/// <param name="evaluator">The project evaluator.</param>
public VisualCppCliProjectChecker(IProjectEvaluator evaluator)
: base(evaluator)
{
}
/// <summary>
/// Check assembly types.
/// </summary>
/// <param name="assemblyDefinition">The assembly.</param>
private void CheckAssemblyTypes(AssemblyDefinition assemblyDefinition, CheckerSharedData checkerData, IProjectEvaluator evaluator)
{
var referencedAssemblyTypes = evaluator.ProjectTypesReferences
.Select(projectTypeRef => projectTypeRef)
.Join(assemblyDefinition.Modules.GetTypesDefinitions().Where(moduleType => moduleType.BaseType != null),
projectTypeRef => projectTypeRef.FullName.ToLower(),
moduleType => moduleType.FullName.ToLower(),
(projectTypeRef, moduleType) => projectTypeRef);
foreach (TypeDefinition referencedType in referencedAssemblyTypes)
{
if (checkerData.UsedTypes.Contains(referencedType.AssemblyQualifiedName()))
{
_memberRefsCheckHelper.Check(referencedType, checkerData, evaluator);
if (!checkerData.HasCandidateReferences)
{
break;
}
}
else
{
checkerData.RemoveFromCandidates(referencedType.Scope);
if (!checkerData.HasCandidateReferences)
{
break;
}
_classCheckHeper.Check(referencedType, checkerData);
if (!checkerData.HasCandidateReferences)
{
break;
}
_interfaceCheckHelper.Check(referencedType, checkerData);
if (!checkerData.HasCandidateReferences)
{
break;
}
_memberRefsCheckHelper.Check(referencedType, checkerData, evaluator);
if (!checkerData.HasCandidateReferences)
{
break;
}
}
}
}
/// <summary>
/// Initialize a new instance of a <see cref="ProjectChecker"/> class.
/// </summary>
/// <param name="evaluator">The project evaluator.</param>
protected ProjectChecker(IProjectEvaluator evaluator)
{
_evaluator = evaluator;
}
/// <summary>
/// Initialize a new instance of a <see cref="DefaultProjectChecker"/> class.
/// </summary>
/// <param name="evaluator">The project evaluator.</param>
public DefaultProjectChecker(IProjectEvaluator evaluator)
: base(evaluator)
{
}
/// <summary>
/// Get list of referenced members of the specified type.
/// </summary>
/// <param name="typeRef">The type reference.</param>
/// <param name="evaluator">The project evaluator.</param>
/// <returns>Returns list of members references.</returns>
private IEnumerable <MemberReference> GetMemberReferences(TypeReference typeRef, IProjectEvaluator evaluator)
{
var typeName = typeRef.FullName;
return(evaluator.MemberReferences
.Where(item => item.DeclaringType.FullName.Equals(typeName, StringComparison.OrdinalIgnoreCase)));
}
public ResourcesReader(IProjectEvaluator evaluator)
{
_evaluator = evaluator;
}
/// <summary>
/// Initialize a new instance of a <see cref="VisualBasicProjectChecker"/> class.
/// </summary>
/// <param name="evaluator">The project evaluator.</param>
public VisualBasicProjectChecker(IProjectEvaluator evaluator)
: base(evaluator)
{
}
/// <summary>
/// Initialize a new instance of the <see cref="XamlTypeResolver"/> class.
/// </summary>
/// <param name="evaluator">The project evaluator.</param>
public XamlTypeResolver(IProjectEvaluator evaluator)
{
_evaluator = evaluator;
_cache = new ProjectReferenceCache(_evaluator);
}
public ProjectReferenceCache(IProjectEvaluator evaluator)
{
_evaluator = evaluator;
}
