public static int GetResourcesCount(Dictionary <ModuleDefinition, Collection <Resource> > resources, bool decompileDangerousResources)
{
int result = 0;
foreach (Collection <Resource> moduleResources in resources.Values)
{
foreach (Resource resource in moduleResources)
{
if (!decompileDangerousResources && DangerousResourceIdentifier.IsDangerousResource(resource))
{
continue;
}
if (resource.ResourceType != ResourceType.Embedded)
{
continue;
}
EmbeddedResource embeddedResource = (EmbeddedResource)resource;
if (resource.Name.EndsWith(".g.resources", StringComparison.OrdinalIgnoreCase))
{
using (ResourceReader resourceReader = new ResourceReader(embeddedResource.GetResourceStream()))
{
result += resourceReader.OfType <System.Collections.DictionaryEntry>().Count();
}
}
else
{
result++;
}
}
}
return(result);
}
private static bool ExistsResourceForType(string typeFullName, AssemblyDefinition assembly, bool decompileDangerousResources)
{
foreach (ModuleDefinition module in assembly.Modules)
{
foreach (Resource resource in module.Resources)
{
if (!decompileDangerousResources && DangerousResourceIdentifier.IsDangerousResource(resource))
{
continue;
}
if (resource.ResourceType != ResourceType.Embedded)
{
continue;
}
EmbeddedResource embeddedResource = (EmbeddedResource)resource;
if (resource.Name.EndsWith(".resources", StringComparison.OrdinalIgnoreCase))
{
if (!embeddedResource.Name.EndsWith(".g.resources", StringComparison.OrdinalIgnoreCase))
{
string resourceName = embeddedResource.Name.Substring(0, embeddedResource.Name.Length - 10); //".resources".Length == 10
if (resourceName == typeFullName)
{
return(true);
}
}
}
}
}
return(false);
}
private bool ShouldDecompileDangerousResources(AssemblyDefinition assembly, string assemblyPath, AssemblyType assemblyType)
{
try
{
Dictionary <ModuleDefinition, Mono.Collections.Generic.Collection <Resource> > assemblyResources = Utilities.GetResources(assembly);
bool containsDangerousResources = assemblyResources.SelectMany(rc => rc.Value)
.Any(resource => DangerousResourceIdentifier.IsDangerousResource(resource));
bool decompileDangerousResources = false;
if (containsDangerousResources)
{
DispatcherObjectExt.Invoke(() =>
{
DangerousResourceDialog dialog = new DangerousResourceDialogWithAnalyticsTracking(Path.GetFileName(assemblyPath), assemblyType);
if (dialog.Show() == DangerousResourceDialogResult.Yes)
{
decompileDangerousResources = true;
}
});
}
return(decompileDangerousResources);
}
catch (Exception)
{
return(false);
}
}
protected void CreateResources(ModuleDefinition module)
{
string targetDir = Path.GetDirectoryName(this.TargetPath);
foreach (Resource resource in module.Resources)
{
try
{
if (!this.decompilationPreferences.DecompileDangerousResources &&
DangerousResourceIdentifier.IsDangerousResource(resource))
{
continue;
}
if (resource.ResourceType != ResourceType.Embedded)
{
continue;
}
EmbeddedResource embeddedResource = (EmbeddedResource)resource;
IFileGeneratedInfo args;
if (resource.Name.EndsWith(".resources", StringComparison.OrdinalIgnoreCase))
{
if (!embeddedResource.Name.EndsWith(".g.resources", StringComparison.OrdinalIgnoreCase))
{
string resourceName = embeddedResource.Name.Substring(0, embeddedResource.Name.Length - 10); //".resources".Length == 10
string relativeResourcePath = resourcesToPathsMap[resource];
string fullResourcePath = Path.Combine(targetDir, relativeResourcePath);
if (TryCreateResXFile(embeddedResource, fullResourcePath))
{
this.projectFileManager.ResourceDesignerMap.Add(resourceName, relativeResourcePath);
args = new FileGeneratedInfo(fullResourcePath, false);
OnProjectFileCreated(args);
}
}
else
{
ProcessXamlResources(embeddedResource, module);
}
}
else
{
string resourceLegalName = resourcesToPathsMap[resource];
string resourceFullPath = Path.Combine(targetDir, resourceLegalName);
using (FileStream fileStream = new FileStream(resourceFullPath, FileMode.Create, FileAccess.Write))
{
embeddedResource.GetResourceStream().CopyTo(fileStream);
}
this.projectFileManager.AddResourceToOtherEmbeddedResources(resourceLegalName);
args = new FileGeneratedInfo(resourceFullPath, false);
OnProjectFileCreated(args);
}
}
catch (Exception ex)
{
if (ResourceWritingFailure != null)
{
ResourceWritingFailure(this, resource.Name, ex);
}
if (this.projectNotifier != null)
{
this.projectNotifier.OnResourceWritingFailure(resource.Name, ex);
}
}
}
}
public Dictionary <Resource, string> GetResourcesToFilePathsMap()
{
Dictionary <Resource, string> result = new Dictionary <Resource, string>();
List <Resource> flattenedResources = new List <Resource>();
Dictionary <Resource, string> flattenedResourcesFileNames = new Dictionary <Resource, string>();
foreach (KeyValuePair <ModuleDefinition, Mono.Collections.Generic.Collection <Resource> > moduleResources in this.resources)
{
foreach (Resource resource in moduleResources.Value)
{
if (!this.decompileDangerousResources &&
DangerousResourceIdentifier.IsDangerousResource(resource))
{
continue;
}
if (resource.ResourceType != ResourceType.Embedded)
{
continue;
}
EmbeddedResource embeddedResource = (EmbeddedResource)resource;
if (resource.Name.EndsWith(".resources", StringComparison.OrdinalIgnoreCase))
{
if (!embeddedResource.Name.EndsWith(".g.resources", StringComparison.OrdinalIgnoreCase))
{
string resourceName = embeddedResource.Name.Substring(0, embeddedResource.Name.Length - 10); //".resources".Length == 10
string relativeResourcePath = GetResourceFilePath(resourceName);
result.Add(resource, relativeResourcePath);
if (relativeResourcePath.Length > maxRelativePathLength || Path.GetDirectoryName(relativeResourcePath) == "")
{
flattenedResources.Add(resource);
string resourceFileName = Path.GetFileName(relativeResourcePath);
flattenedResourcesFileNames.Add(resource, resourceFileName);
result[resource] = Path.GetFileName(resourceFileName);
}
}
}
else
{
string resourceLegalName = Utilities.GetLegalFileName(resource.Name);
result.Add(resource, resourceLegalName);
// such resources are always in the root directory of the project,
// so we add them, like the "" namespace types in GetTypesToFilePathsMap algorithm
flattenedResources.Add(resource);
flattenedResourcesFileNames.Add(resource, resourceLegalName);
}
}
}
// now we've got some resources flattened, we must fix any collisions and
// after that rename any resources with still long paths.
// note that if we have any code file along a resource, its path will
// surely be with shorter path, since ".resx".Length() > ".cs"/".vb".Length()
FixResourcesCollisions(result, flattenedResources, flattenedResourcesFileNames);
HashSet <string> usedNames = new HashSet <string>();
foreach (Resource resource in flattenedResources)
{
usedNames.Add(result[resource]);
}
int longResourcesNamesCount = 0;
foreach (Resource resource in flattenedResources)
{
string currentResourceName = result[resource];
string resourceExtension = Path.GetExtension(currentResourceName);
if (currentResourceName.Length + sourceExtension.Length > maxRelativePathLength)
{
longResourcesNamesCount++;
string nameCandidate = ResourcesShortNameStartSymbol + longResourcesNamesCount + resourceExtension;
while (usedNames.Contains(nameCandidate))
{
longResourcesNamesCount++;
nameCandidate = ResourcesShortNameStartSymbol + longResourcesNamesCount + resourceExtension;
}
usedNames.Remove(currentResourceName);
usedNames.Add(nameCandidate);
result[resource] = nameCandidate;
}
}
return(result);
}
public override Task <GetProjectCreationMetadataResponse> GetProjectCreationMetadata(GetProjectCreationMetadataRequest request, ServerCallContext context)
{
VisualStudioVersion visualStudioVersion = this.GetProjectCreationVSVersion(request.ProjectVisualStudioVersion);
AssemblyDefinition assemblyDefinition = GlobalAssemblyResolver.Instance.GetAssemblyDefinition(request.AssemblyFilePath);
ILanguage language = LanguageFactory.GetLanguage(CSharpVersion.V7);
ProjectGenerationSettings settings = ProjectGenerationSettingsProvider.GetProjectGenerationSettings(request.AssemblyFilePath, NoCacheAssemblyInfoService.Instance,
EmptyResolver.Instance, visualStudioVersion, language, TargetPlatformResolver.Instance);
bool containsDangerousResources = assemblyDefinition.Modules.SelectMany(m => m.Resources).Any(r => DangerousResourceIdentifier.IsDangerousResource(r));
string normalizedVSProjectFileExtension = language.VSProjectFileExtension.TrimStart('.');
string generatedProjectExtension = normalizedVSProjectFileExtension + (settings.JustDecompileSupportedProjectType ? string.Empty : MSBuildProjectBuilder.ErrorFileExtension);
return(Task.FromResult(new GetProjectCreationMetadataResponse()
{
ContainsDangerousResources = containsDangerousResources,
ProjectFileMetadata = new ProjectFileMetadata()
{
IsDecompilerSupportedProjectType = settings.JustDecompileSupportedProjectType,
IsVSSupportedProjectType = settings.VisualStudioSupportedProjectType,
ProjectTypeNotSupportedErrorMessage = settings.ErrorMessage ?? string.Empty,
ProjectFileName = assemblyDefinition.Name.Name,
ProjectFileExtension = generatedProjectExtension
}
}));
}
