private string ToFrameworkProfile(FrameworkProfile targetFrameworkProfile)
{
switch (targetFrameworkProfile)
{
case FrameworkProfile.Default:
return(string.Empty);
case FrameworkProfile.Client:
return("client");
default:
throw new ArgumentOutOfRangeException("targetFrameworkProfile");
}
}
public MakePortableSkeletonProcessor(FrameworkProfile frameworkProfile)
{
_frameworkProfile = frameworkProfile;
}
public RetargetReferencesProcessor(FrameworkProfile frameworkProfile, bool removeOthers = false)
: this(frameworkProfile.GetFrameworkAssemblies(), removeOthers)
{
}
public override void Initialize()
{
IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());
Configuration.Modules.AbpAutoMapper().Configurators.Add(FrameworkProfile.DefaultAutoMapperConfig());
}
public override void Execute()
{
var profile = FrameworkProfile.Parse(Profile);
new MakePortableSkeletonProcessor(profile).ProcessAssemblyFromFile(Input, Output);
}
public override void Execute()
{
var profile = FrameworkProfile.Parse(Profile);
new RetargetReferencesProcessor(profile, RemoveOthers).ProcessAssemblyFromFile(Input, Output);
}
public SetTargetFrameworkProcessor(FrameworkProfile frameworkProfile)
: this(frameworkProfile.FullName)
{
}
public RetargetAssemblyProcessor(string frameworkProfile, bool removeOtherReferences = false)
: this(FrameworkProfile.Parse(frameworkProfile), removeOtherReferences)
{
}
public RetargetAssemblyProcessor(FrameworkProfile frameworkProfile, bool removeOtherReferences = false)
{
_frameworkProfile = frameworkProfile;
_removeOtherReferences = removeOtherReferences;
}
public CollectUsedTypesProcessor(FrameworkProfile frameworkProfile)
{
_frameworkProfile = frameworkProfile;
}
protected override void ProcessAssembly(AssemblyDefinition assemblyDef)
{
if (_frameworkProfile == null)
{
_frameworkProfile = assemblyDef.GuessAssemblyProfile();
}
if (_frameworkProfile != null)
{
foreach (var moduleDef in assemblyDef.Modules)
{
var resolver = moduleDef.AssemblyResolver as DefaultAssemblyResolver;
if (resolver != null)
{
resolver.AddSearchDirectory(_frameworkProfile.ReferencesDirectory);
}
}
}
_usedTypeReferences = new HashSet <TypeReference>(CecilEqualityComparer.Default);
base.ProcessAssembly(assemblyDef);
var unprocessedTypes = new Queue <TypeReference>(_usedTypeReferences);
_usedTypeReferences = null;
var processedTypes = new HashSet <TypeDefinition>(CecilEqualityComparer.Default);
var unresolvedTypes = new HashSet <TypeReference>(CecilEqualityComparer.Default);
while (unprocessedTypes.Any())
{
var typeRef = unprocessedTypes.Dequeue();
if (typeRef == null)
{
continue;
}
if (typeRef.IsGenericParameter)
{
continue;
}
var typeSpec = typeRef as TypeSpecification;
if (typeSpec != null)
{
var elementType = typeSpec.ElementType;
Debug.Assert(elementType != null);
unprocessedTypes.Enqueue(elementType);
var genericInstanceTypeRef = typeRef as GenericInstanceType;
if (genericInstanceTypeRef != null)
{
foreach (var genericArgument in genericInstanceTypeRef.GenericArguments)
{
unprocessedTypes.Enqueue(genericArgument);
}
}
var requiredModifierTypeRef = typeRef as RequiredModifierType;
if (requiredModifierTypeRef != null)
{
unprocessedTypes.Enqueue(requiredModifierTypeRef.ModifierType);
}
var optionalModifierTypeRef = typeRef as OptionalModifierType;
if (optionalModifierTypeRef != null)
{
unprocessedTypes.Enqueue(optionalModifierTypeRef.ModifierType);
}
var functionPointerTypeRef = typeRef as FunctionPointerType;
if (functionPointerTypeRef != null)
{
unprocessedTypes.Enqueue(functionPointerTypeRef.ReturnType);
foreach (var parameter in functionPointerTypeRef.Parameters)
{
unprocessedTypes.Equals(parameter.ParameterType);
foreach (var customAttr in parameter.CustomAttributes)
{
unprocessedTypes.Enqueue(customAttr.AttributeType);
}
}
foreach (var customAttr in functionPointerTypeRef.MethodReturnType.CustomAttributes)
{
unprocessedTypes.Enqueue(customAttr.AttributeType);
}
}
continue;
}
var typeDef = typeRef as TypeDefinition;
if (typeDef == null)
{
typeDef = typeRef.TryResolve();
if (typeDef != null)
{
unprocessedTypes.Enqueue(typeDef);
}
else
{
unresolvedTypes.Add(typeRef);
Debug.WriteLine(string.Format("Cannot resolve type {0}", typeRef.FullName));
}
continue;
}
processedTypes.Add(typeDef);
}
_resolvedTypes = processedTypes;
_unresolvedTypes = unresolvedTypes;
_allTypes = new HashSet <TypeReference>(_unresolvedTypes.Concat(_resolvedTypes), CecilEqualityComparer.Default);
}
public override void Execute()
{
var frameworkProfile = Profile != null?FrameworkProfile.Parse(Profile) : null;
new RemoveExternalTypesUsageProcessor(frameworkProfile, RemoveNonRetargetable).ProcessAssemblyFromFile(Input, Output);
}
protected override void ProcessAssembly(AssemblyDefinition assemblyDef)
{
if (_frameworkProfile == null)
{
_frameworkProfile = assemblyDef.GuessAssemblyProfile();
}
if (_frameworkProfile != null)
{
_assemblyResolver.AddSearchDirectory(_frameworkProfile.ReferencesDirectory);
}
var typesDependenciesCollector = new CollectTypesDependenciesProcessor(_frameworkProfile);
typesDependenciesCollector.Process(assemblyDef);
var goodAssemblyNames = assemblyDef.Modules.SelectMany(asmDef => asmDef.AssemblyReferences);
if (_removeNonRetargetable)
{
goodAssemblyNames = goodAssemblyNames.Where(asmRef => asmRef.IsRetargetable);
}
if (_frameworkProfile != null)
{
goodAssemblyNames = goodAssemblyNames.Concat(_frameworkProfile.GetFrameworkAssemblies());
}
var goodModules = new HashSet <ModuleDefinition>(CecilEqualityComparer.Default);
goodModules.AddRange(assemblyDef.Modules);
goodModules.AddRange(goodAssemblyNames.Select(_assemblyResolver.TryResolve).Where(asmDef => asmDef != null).SelectMany(asmDef => asmDef.Modules));
var allTypesDependencies = typesDependenciesCollector.AllTypesDependencies;
var typeDependenciesToRemove = new Queue <TypeReferenceAndDependencies>(allTypesDependencies.Where(
kv => {
var typeRef = kv.Key;
var typeDef = typeRef.TryResolve();
return(typeDef == null || !goodModules.Contains(typeDef.Module));
}).Select(kv => (TypeReferenceAndDependencies)kv));
var removedDependencies = new HashSet <TypeDependency>();
while (typeDependenciesToRemove.Any())
{
var typeDependencies = typeDependenciesToRemove.Dequeue();
var typeRef = typeDependencies.Type;
var dependencies = typeDependencies.DependingMembers;
Trace.WriteLine(string.Format("Removing dependencies on type {0}:", typeRef), "RemoveExternalTypesUsage");
Trace.Indent();
foreach (var dependency in dependencies)
{
if (!removedDependencies.Contains(dependency))
{
dependency.Break();
removedDependencies.Add(dependency);
var baseClassDependency = dependency as BaseClassDependency;
if (baseClassDependency != null)
{
var removedClass = baseClassDependency.DerivedClass;
if (allTypesDependencies.ContainsKey(removedClass))
{
var removedClassDependencies = allTypesDependencies[removedClass];
typeDependenciesToRemove.Enqueue(new TypeReferenceAndDependencies(removedClass, removedClassDependencies));
}
}
}
}
Trace.Unindent();
}
base.ProcessAssembly(assemblyDef);
}
public RemoveExternalTypesUsageProcessor(FrameworkProfile frameworkProfile, bool removeNonRetargetable = false)
{
_frameworkProfile = frameworkProfile;
_removeNonRetargetable = removeNonRetargetable;
}
protected override void ProcessAssembly(AssemblyDefinition assemblyDef)
{
if (_frameworkProfile == null)
{
_frameworkProfile = assemblyDef.GuessAssemblyProfile();
}
if (_frameworkProfile != null)
{
foreach (var moduleDef in assemblyDef.Modules)
{
var resolver = moduleDef.AssemblyResolver as DefaultAssemblyResolver;
if (resolver != null)
{
resolver.AddSearchDirectory(_frameworkProfile.ReferencesDirectory);
}
}
}
_usedTypeReferences = new Dictionary <TypeReference, HashSet <TypeDependency> >(CecilEqualityComparer.Default);
base.ProcessAssembly(assemblyDef);
var unprocessedTypes = new Queue <TypeReferenceAndDependencies>(_usedTypeReferences.Select(kv => (TypeReferenceAndDependencies)kv));
_usedTypeReferences = null;
var processedTypes = new Dictionary <TypeDefinition, HashSet <TypeDependency> >(CecilEqualityComparer.Default);
var unresolvedTypes = new Dictionary <TypeReference, HashSet <TypeDependency> >(CecilEqualityComparer.Default);
while (unprocessedTypes.Any())
{
var typeDependencies = unprocessedTypes.Dequeue();
var typeRef = typeDependencies.Type;
var dependentMembers = typeDependencies.DependingMembers;
if (typeRef == null)
{
continue;
}
if (typeRef.IsGenericParameter)
{
continue;
}
var typeSpec = typeRef as TypeSpecification;
if (typeSpec != null)
{
var elementType = typeSpec.ElementType;
Debug.Assert(elementType != null);
unprocessedTypes.Enqueue(new TypeReferenceAndDependencies(elementType, dependentMembers));
var genericInstanceTypeRef = typeRef as GenericInstanceType;
if (genericInstanceTypeRef != null)
{
foreach (var genericArgument in genericInstanceTypeRef.GenericArguments)
{
unprocessedTypes.Enqueue(new TypeReferenceAndDependencies(genericArgument, dependentMembers));
}
}
var requiredModifierTypeRef = typeRef as RequiredModifierType;
if (requiredModifierTypeRef != null)
{
unprocessedTypes.Enqueue(new TypeReferenceAndDependencies(requiredModifierTypeRef.ModifierType, dependentMembers));
}
var optionalModifierTypeRef = typeRef as OptionalModifierType;
if (optionalModifierTypeRef != null)
{
unprocessedTypes.Enqueue(new TypeReferenceAndDependencies(optionalModifierTypeRef.ModifierType, dependentMembers));
}
var functionPointerTypeRef = typeRef as FunctionPointerType;
if (functionPointerTypeRef != null)
{
unprocessedTypes.Enqueue(new TypeReferenceAndDependencies(functionPointerTypeRef.ReturnType, dependentMembers));
foreach (var parameter in functionPointerTypeRef.Parameters)
{
unprocessedTypes.Equals(parameter.ParameterType);
foreach (var customAttr in parameter.CustomAttributes)
{
unprocessedTypes.Enqueue(new TypeReferenceAndDependencies(customAttr.AttributeType, dependentMembers));
}
}
foreach (var customAttr in functionPointerTypeRef.MethodReturnType.CustomAttributes)
{
unprocessedTypes.Enqueue(new TypeReferenceAndDependencies(customAttr.AttributeType, dependentMembers));
}
}
continue;
}
var typeDef = typeRef as TypeDefinition;
if (typeDef == null)
{
typeDef = typeRef.TryResolve();
if (typeDef != null)
{
unprocessedTypes.Enqueue(new TypeReferenceAndDependencies(typeDef, dependentMembers));
}
else
{
AddDependencies(unresolvedTypes, typeDependencies);
Trace.WriteLine(string.Format("Warning: Couldn't resolve type {0}", typeRef.FullName), "CollectTypesDependencies");
}
continue;
}
AddDependencies(processedTypes, new TypeDefinitionAndDependencies(typeDef, dependentMembers));
}
_resolvedTypesDependencies = processedTypes;
_unresolvedTypesDependencies = unresolvedTypes;
_allTypesDependencies = new Dictionary <TypeReference, HashSet <TypeDependency> >(_unresolvedTypesDependencies, CecilEqualityComparer.Default);
foreach (var resolvedTypeDependencies in _resolvedTypesDependencies)
{
_allTypesDependencies.Add(resolvedTypeDependencies.Key, resolvedTypeDependencies.Value);
}
}
public CollectTypesDependenciesProcessor(FrameworkProfile frameworkProfile)
{
_frameworkProfile = frameworkProfile;
}
