public static FrameworkVersion ToFrameworkVersion(ExtendedFrameworkVersion version)
{
if (version == ExtendedFrameworkVersion.Version35ClientProfile)
return FrameworkVersion.Version35;
if (version == ExtendedFrameworkVersion.Version40ClientProfile)
return FrameworkVersion.Version40;
return (FrameworkVersion)version;
}
public static ExtendedFrameworkVersion GetSilverlightVersion(ExtendedFrameworkVersion version)
{
if (version == ExtendedFrameworkVersion.Version30)
return ExtendedFrameworkVersion.Version30Silverlight;
if (version == ExtendedFrameworkVersion.Version40)
return ExtendedFrameworkVersion.Version40Silverlight;
return version;
}
public static ExtendedFrameworkVersion GetClientProfileVersion(ExtendedFrameworkVersion version)
{
if (version == ExtendedFrameworkVersion.Version35)
return ExtendedFrameworkVersion.Version35ClientProfile;
if (version == ExtendedFrameworkVersion.Version40)
return ExtendedFrameworkVersion.Version40ClientProfile;
return version;
}
public void Load(BinaryReader reader, ExtendedFrameworkVersion frameworkVersion)
{
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
TypeToAssemblyNamespaceMap map = LoadAssemblyMap(reader, frameworkVersion);
if (map != null)
{
string fileName = map._AssemblyPath.ToLowerInvariant();
_Assemblies[fileName] = map;
}
}
MergeAssemblyMaps();
}
TypeToAssemblyNamespaceMap LoadAssemblyMap(BinaryReader reader, ExtendedFrameworkVersion frameworkVersion)
{
TypeToAssemblyNamespaceMap result = new TypeToAssemblyNamespaceMap();
result._AssemblyPath = reader.ReadString();
result._AssemblySignature = FileSignature.Read(reader);
int typeCount = reader.ReadInt32();
for (int typeIndex = 0; typeIndex < typeCount; typeIndex++)
{
string typeName = reader.ReadString();
int namespaceCount = reader.ReadInt32();
if (!result.ContainsKey(typeName))
result.Add(typeName, new AssemblyNamespaceList());
AssemblyNamespaceList assemblyNamespaces = result.GetNamespaceList(typeName);
for (int i = 0; i < namespaceCount; i++)
{
int assemblyIndex = reader.ReadInt32();
int namespaceIndex = reader.ReadInt32();
assemblyNamespaces.Add(new AssemblyNamespace(frameworkVersion, assemblyIndex, namespaceIndex));
}
}
return result;
}
List<TypeToAssemblyNamespaceMap> CollectTypesFromAssemblies(List<FileInfo> files, IAssemblyScanProgress progress, ExtendedFrameworkVersion frameworkVersion)
{
List<TypeToAssemblyNamespaceMap> result = new List<TypeToAssemblyNamespaceMap>();
for (int i = 0; i < files.Count; i++)
{
try
{
FileInfo fileInfo = files[i];
string text = fileInfo.Name;
progress.UpdateProgress(i, text);
TypeToAssemblyNamespaceMap typeAssemblyMap = CollectTypes(fileInfo.FullName, frameworkVersion);
if (typeAssemblyMap != null)
result.Add(typeAssemblyMap);
}
catch (Exception ex)
{
Log.SendException(ex);
}
}
return result;
}
TypeToAssemblyNamespaceMap CollectTypes(string assemblyPath, ExtendedFrameworkVersion frameworkVersion)
{
assemblyPath = assemblyPath.ToLowerInvariant();
TypeToAssemblyNamespaceMap result = new TypeToAssemblyNamespaceMap();
result._AssemblyPath = assemblyPath;
result._AssemblySignature = new FileSignature(assemblyPath);
AssemblyTypeLoadResult typeLoadResult = LoadTypesFromAssembly(assemblyPath);
if (typeLoadResult == null)
return result;
foreach (ITypeInfo typeInfo in typeLoadResult.Types)
{
if (!result.ContainsKey(typeInfo.NestedName))
result.Add(typeInfo.NestedName, new AssemblyNamespaceList());
AssemblyNamespaceList list = result.GetNamespaceList(typeInfo.NestedName);
list.AddUnique(new AssemblyNamespace(typeLoadResult.AssemblyInfo.FullName, typeInfo.Namespace, frameworkVersion));
}
return result;
}
static string GetFrameworkVersionStr(ExtendedFrameworkVersion frameworkVersion)
{
switch (frameworkVersion)
{
case ExtendedFrameworkVersion.Version10:
return "1.0";
case ExtendedFrameworkVersion.Version11:
return "1.1";
case ExtendedFrameworkVersion.Version20:
return "2.0";
case ExtendedFrameworkVersion.Version30:
return "3.0";
case ExtendedFrameworkVersion.Version35:
return "3.5";
case ExtendedFrameworkVersion.Version40:
return "4.0";
default:
return "";
}
}
public void ScanFrameworkAssemblies(ExtendedFrameworkVersion frameworkVersion, string[] frameworkPaths)
{
RunOperationWithWaitCursor(() =>
{
AssemblyNamespace.InitializeCache(frameworkVersion);
List<FileInfo> files = GetAssembliesToScan(frameworkPaths);
if (files == null || files.Count == 0)
return;
IAssemblyScanProgress progress = StartAssembliesScan(frameworkVersion, files);
try
{
List<TypeToAssemblyNamespaceMap> typeAssemblyMaps = CollectTypesFromAssemblies(files, progress, frameworkVersion);
if (typeAssemblyMaps != null)
AddTypeAssemblyMaps(typeAssemblyMaps);
MergeAssemblyMaps();
}
finally
{
progress.Stop();
}
});
}
public static void LoadCache(CacheFileSystem fileSystem, ExtendedFrameworkVersion frameworkVersion)
{
if (assemblyCache.ContainsKey(frameworkVersion))
assemblyCache[frameworkVersion].Clear();
else
assemblyCache.Add(frameworkVersion, new List<string>());
string fileName = GetFileName(frameworkVersion);
Stream stream = fileSystem.Read(fileName);
if (stream == null)
return;
using (BinaryReader reader = new BinaryReader(stream))
{
bool hasAssemblyCache = reader.ReadBoolean();
if (hasAssemblyCache)
assemblyCache[frameworkVersion].AddRange(ReadStrings(reader));
namespaceCache.Clear();
namespaceCache.AddRange(ReadStrings(reader));
}
}
public AssemblyNamespace(ExtendedFrameworkVersion frameworkVersion, int assemblyIndex, int namespaceIndex)
{
this.frameworkVersion = frameworkVersion;
this.assemblyIndex = assemblyIndex;
this.namespaceIndex = namespaceIndex;
}
public AssemblyNamespace(string assemblyName, string @namespace, ExtendedFrameworkVersion frameworkVersion)
{
this.frameworkVersion = frameworkVersion;
Assembly = assemblyName;
Namespace = @namespace;
}
static string GetFileName(ExtendedFrameworkVersion frameworkVersion)
{
return String.Format(STR_AssemblyCacheFormat, frameworkVersion);
}
public static void SaveCache(CacheFileSystem fileSystem, ExtendedFrameworkVersion frameworkVersion)
{
string fileName = GetFileName(frameworkVersion);
using (MemoryStream stream = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(stream))
{
bool hasAssemblyCache = assemblyCache.ContainsKey(frameworkVersion);
writer.Write(hasAssemblyCache);
if (hasAssemblyCache)
WriteStrings(writer, assemblyCache[frameworkVersion].ToArray());
WriteStrings(writer, namespaceCache.ToArray());
writer.Flush();
stream.Position = 0;
fileSystem.Write(fileName, stream);
}
}
}
IAssemblyScanProgress StartAssembliesScan(ExtendedFrameworkVersion frameworkVersion, List<FileInfo> files)
{
FrmCollectingClasses frmCollectingClasses = new FrmCollectingClasses();
string frameworkVersionStr = GetFrameworkVersionStr(frameworkVersion);
frmCollectingClasses.PerformingScanText = String.Format("Performing a one-time scan of the .NET {0} framework....", frameworkVersionStr);
frmCollectingClasses.Show();
frmCollectingClasses.Refresh();
frmCollectingClasses.Start(files.Count);
return frmCollectingClasses;
}
public static ExtendedFrameworkVersion GetWindowsPhoneProfileVersion(ExtendedFrameworkVersion version)
{
if (version == ExtendedFrameworkVersion.Version40)
return ExtendedFrameworkVersion.Version40SilverlightWindowsPhone;
return version;
}
// public static methods...
public static void InitializeCache(ExtendedFrameworkVersion frameworkVersion)
{
if (!assemblyCache.ContainsKey(frameworkVersion))
assemblyCache.Add(frameworkVersion, new List<string>());
}
