public bool TryGetSource(FileKey key, out ValueSource<AssemblyMetadata> source)
{
lock (_gate)
{
return _metadataCache.TryGetValue(key, out source);
}
}
public bool TryGetMetadata(FileKey key, out AssemblyMetadata metadata)
{
lock (_gate)
{
return TryGetMetadata_NoLock(key, out metadata);
}
}
private bool TryGetMetadata_NoLock(FileKey key, out AssemblyMetadata metadata)
{
if (_metadataCache.TryGetValue(key, out var metadataSource))
{
metadata = metadataSource.GetValue();
return metadata != null;
}
metadata = null;
return false;
}
public override void InsertNewObjectFromStrings(string[] parts, FileKey fk)
{
if (parts.Length >= 5 && parts[0].Length > 0)
{
NumberFormatInfo fmt = new NumberFormatInfo();
GPLocation location = new GPLocation();
location.setCity(parts[0]);
location.setLatitudeNorthPositive(double.Parse(parts[1], fmt));
location.setLongitudeEastPositive(double.Parse(parts[2], fmt));
location.setCountryCode(parts[3]);
location.setTimeZoneName(parts[4]);
locations.Add(location);
}
}
// Load Poses List
private void Load_PosesList_Button(object sender, RoutedEventArgs e)
{
System.Windows.Forms.OpenFileDialog ofd = new System.Windows.Forms.OpenFileDialog();
ofd.Multiselect = false;
ofd.Filter = "Pose List File (*.pbtc)|*.pbtc";
if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
btc.LoadPosesList(ofd.FileName.ToString(), true, FileKey.ToString());
}
interfaceManager.UpdatePoseLists();
}
/// <summary>
/// A unique file key encapsulates a file path, and change date
/// that can be used as the key to a dictionary.
/// If a file hasn't changed name or timestamp, we assume
/// it is unchanged.
///
/// Returns null if the file doesn't exist or otherwise can't be accessed.
/// </summary>
private FileKey?GetUniqueFileKey(string filePath)
{
try
{
return(FileKey.Create(filePath));
}
catch (Exception)
{
// There are several exceptions that can occur here: NotSupportedException or PathTooLongException
// for a bad path, UnauthorizedAccessException for access denied, etc. Rather than listing them all,
// just catch all exceptions.
return(null);
}
}
private MetadataShadowCopy GetMetadataShadowCopyNoCheck(string fullPath, MetadataImageKind kind)
{
if (kind < MetadataImageKind.Assembly || kind > MetadataImageKind.Module)
{
throw new ArgumentOutOfRangeException(nameof(kind));
}
FileKey key = FileKey.Create(fullPath);
lock (Guard)
{
CacheEntry <MetadataShadowCopy> existing;
if (CopyExistsOrIsSuppressed(key, out existing))
{
return(existing.Public);
}
}
CacheEntry <MetadataShadowCopy> newCopy = CreateMetadataShadowCopy(fullPath, kind);
// last-write timestamp is copied from the original file at the time the snapshot was made:
bool fault = true;
try
{
key = new FileKey(fullPath, FileUtilities.GetFileTimeStamp(newCopy.Public.PrimaryModule.FullPath));
fault = false;
}
finally
{
if (fault)
{
newCopy.Private.Dispose();
}
}
lock (Guard)
{
CacheEntry <MetadataShadowCopy> existing;
if (CopyExistsOrIsSuppressed(key, out existing))
{
newCopy.Private.Dispose();
return(existing.Public);
}
_shadowCopies.Add(key, newCopy);
}
return(newCopy.Public);
}
private ModuleMetadata CreateModuleMetadataFromTemporaryStorage(FileKey moduleFileKey, List <ITemporaryStreamStorage>?storages)
{
GetStorageInfoFromTemporaryStorage(moduleFileKey, out var storage, out var stream, out var pImage);
var metadata = ModuleMetadata.CreateFromMetadata(pImage, (int)stream.Length);
// first time, the metadata is created. tie lifetime.
s_lifetimeMap.Add(metadata, stream);
// hold onto storage if requested
storages?.Add(storage);
return(metadata);
}
private bool TryCreateAssemblyMetadataFromMetadataImporter(FileKey fileKey, [NotNullWhen(true)] out AssemblyMetadata?metadata)
{
metadata = null;
var manifestModule = TryCreateModuleMetadataFromMetadataImporter(fileKey);
if (manifestModule == null)
{
return(false);
}
metadata = CreateAssemblyMetadata(fileKey, manifestModule, storages: null, CreateModuleMetadata);
return(true);
}
/// <exception cref="IOException"/>
/// <exception cref="BadImageFormatException" />
private bool TryCreateAssemblyMetadataFromMetadataImporter(FileKey fileKey, out AssemblyMetadata metadata)
{
metadata = default;
var manifestModule = TryCreateModuleMetadataFromMetadataImporter(fileKey);
if (manifestModule == null)
{
return(false);
}
metadata = CreateAssemblyMetadata(fileKey, manifestModule, null, CreateModuleMetadata);
return(true);
}
internal void TryParse_LangPack(FileKey fileKey)
{
if (_minimizeFileIo)
{
return;
}
if (_fileIO.TryReadEncryptedFile(fileKey, FilePath.User, _localKey, out FileReadDescriptor file).NotSuccessful())
{
return;
}
DataStream stream = file.DataStream;
}
internal IEnumerable<ITemporaryStreamStorage> GetStorages(string fullPath, DateTime snapshotTimestamp)
{
var key = new FileKey(fullPath, snapshotTimestamp);
// check existing metadata
if (_metadataCache.TryGetSource(key, out var source))
{
var metadata = source as RecoverableMetadataValueSource;
if (metadata != null)
{
return metadata.GetStorages();
}
}
return null;
}
private ModuleMetadata?TryCreateModuleMetadataFromMetadataImporter(FileKey moduleFileKey)
{
if (!TryGetFileMappingFromMetadataImporter(moduleFileKey, out var info, out var pImage, out var length))
{
return(null);
}
Debug.Assert(pImage != IntPtr.Zero, "Base address should not be zero if GetFileFlatMapping call succeeded.");
var metadata = ModuleMetadata.CreateFromImage(pImage, (int)length);
s_lifetimeMap.Add(metadata, info);
return(metadata);
}
internal IEnumerable <ITemporaryStreamStorage>?GetStorages(string fullPath, DateTime snapshotTimestamp)
{
var key = new FileKey(fullPath, snapshotTimestamp);
// check existing metadata
if (_metadataCache.TryGetSource(key, out var source))
{
if (source is RecoverableMetadataValueSource metadata)
{
return(metadata.GetStorages());
}
}
return(null);
}
public void Configure(EntityTypeBuilder <SupplyList> builder)
{
builder.ToTable("SupplyLists", SupplyContextSchemes.Deault);
builder.Property(e => e.BarCode)
.HasConversion(e => e.ToString(), e => SupplyBarCode.Parse(e));
builder.Property(e => e.FileKey)
.HasConversion(e => e.ToString(), e => FileKey.Parse(e));
builder.Property(e => e.FileKey);
builder.Property(e => e.BarCode);
builder.Property <int>("Id").ValueGeneratedOnAdd();
builder.HasKey("Id");
}
/// <summary>
/// Gets or creates metadata for specified file path.
/// </summary>
/// <param name="fullPath">Full path to an assembly manifest module file or a standalone module file.</param>
/// <param name="kind">Metadata kind (assembly or module).</param>
/// <returns>Metadata for the specified file.</returns>
/// <exception cref="IOException">Error reading file <paramref name="fullPath"/>. See <see cref="Exception.InnerException"/> for details.</exception>
public Metadata GetMetadata(string fullPath, MetadataImageKind kind)
{
if (NeedsShadowCopy(fullPath))
{
return(GetMetadataShadowCopyNoCheck(fullPath, kind).Metadata);
}
FileKey key = FileKey.Create(fullPath);
lock (Guard)
{
CacheEntry <Metadata> existing;
if (_noShadowCopyCache.TryGetValue(key, out existing))
{
return(existing.Public);
}
}
Metadata newMetadata;
if (kind == MetadataImageKind.Assembly)
{
newMetadata = AssemblyMetadata.CreateFromFile(fullPath);
}
else
{
newMetadata = ModuleMetadata.CreateFromFile(fullPath);
}
// the files are locked (memory mapped) now
key = FileKey.Create(fullPath);
lock (Guard)
{
CacheEntry <Metadata> existing;
if (_noShadowCopyCache.TryGetValue(key, out existing))
{
newMetadata.Dispose();
return(existing.Public);
}
Metadata publicMetadata = newMetadata.Copy();
_noShadowCopyCache.Add(key, new CacheEntry <Metadata>(publicMetadata, newMetadata));
return(publicMetadata);
}
}
public void Local_ExceptionPaths()
{
var fm = new LocalNetworkFileManager();
var key = new FileKey()
{
ID = null, FileType = FileType.Avatar
};
VerifyPath(fm, key, "");
key = new FileKey()
{
ID = "", FileType = FileType.Avatar
};
VerifyPath(fm, key, "");
}
public void ContentDelivery_ExceptionPaths()
{
var fm = new AzureBlobFileManager("");
var key = new FileKey()
{
ID = null, FileType = FileType.Avatar
};
VerifyPath(fm, key, "");
key = new FileKey()
{
ID = "", FileType = FileType.Avatar
};
VerifyPath(fm, key, "");
}
private async Task <Tuple <string, FileKey> > UploadAvatar(Account account, CancellationToken cancellationToken)
{
var picture = account.Picture;
if (!Uri.TryCreate(picture, UriKind.Absolute, out Uri pictureUri))
{
return(null);
}
if (pictureUri.Scheme != "file" || !File.Exists(picture)) // Это локальный файл, и его нужно отправить на сервер
{
return(null);
}
byte[] fileHash = null;
using (var stream = File.OpenRead(picture))
{
using (var sha1 = new System.Security.Cryptography.SHA1Managed())
{
fileHash = sha1.ComputeHash(stream);
}
}
var fileKey = new FileKey {
Name = Path.GetFileName(picture), Hash = fileHash
};
// Если файла на сервере нет, загрузим его
var picturePath = await _gameServerClient.HasPicture(fileKey);
if (picturePath == null)
{
using (var stream = File.OpenRead(picture))
{
picturePath = await _gameServerClient.UploadPicture(fileKey, stream, cancellationToken);
}
}
if (!Uri.IsWellFormedUriString(picturePath, UriKind.Absolute))
{
var rootAddress = _gamesHostInfo.ContentPublicBaseUrls.FirstOrDefault() ?? _gameServerClient.ServerAddress;
picturePath = rootAddress + picturePath;
}
return(Tuple.Create(picturePath, fileKey));
}
public async Task ContentDelivery_FileLifeCycle()
{
string fmType = "AzureBlob";
var handler = FileManagerConfigurationSettings.Instance.Handlers.FirstOrDefault(x => x.Name.IsEqual(fmType));
if (handler == null)
{
Assert.Inconclusive($"Can't find {fmType}");
}
var fm = handler.Construct <AzureBlobFileManager>();
if (fm == null)
{
Assert.Inconclusive($"Can't construct {fmType}");
}
var fileName = Guid.NewGuid().ToString() + ".png";
var key = new FileKey()
{
ID = fileName, FileType = FileType.Thumbnail
};
//string partialPath = String.Join("/", new string[] { VoatSettings.Instance.DestinationPathThumbs, fileName }.ToPathParts());
Assert.IsFalse(await fm.Exists(key));
using (var httpRehorse = new HttpResource("https://voat.co/Graphics/voat-goat.png"))
{
await httpRehorse.GiddyUp();
await fm.Upload(key, httpRehorse.Stream);
}
Assert.IsTrue(await fm.Exists(key));
var url = fm.Uri(key, new PathOptions()
{
FullyQualified = true, ProvideProtocol = true
});
//Assert.AreEqual($"/{partialPath}", url, "Condition:1.1");
await fm.Delete(key);
Assert.IsFalse(await fm.Exists(key));
}
public static async Task <CommandResponse <string> > GenerateAvatar(Stream imageStream, string fileName, string mimetype, bool purgeTempFile = true)
{
var fileManager = FileManager.Instance;
var fileCheck = fileManager.IsUploadPermitted(fileName, FileType.Avatar, mimetype, imageStream.Length);
if (fileCheck.Success)
{
var key = new FileKey();
key.FileType = FileType.Avatar;
key.ID = await GenerateRandomFilename(Path.GetExtension(fileName), FileType.Avatar);
await GenerateImageThumbnail(fileManager, key, imageStream, VoatSettings.Instance.AvatarSize, false, false);
return(CommandResponse.Successful(key.ID));
}
return(CommandResponse.FromStatus <string>(null, fileCheck.Status, fileCheck.Message));
}
public IEnumerable <ITemporaryStreamStorage> GetStorages(string fullPath, DateTime snapshotTimestamp)
{
var key = new FileKey(fullPath, snapshotTimestamp);
// check existing metadata
ValueSource <AssemblyMetadata> source;
if (_metadataCache.TryGetSource(key, out source))
{
var metadata = source as RecoverableMetadataValueSource;
if (metadata != null)
{
return(metadata.GetStorages());
}
}
return(null);
}
public bool TryGetOrAddMetadata(FileKey key, ValueSource <AssemblyMetadata> newMetadata, out AssemblyMetadata metadata)
{
lock (_gate) {
if (TryGetMetadata_NoLock(key, out metadata))
{
return(false);
}
EnsureCapacity_NoLock();
metadata = newMetadata.GetValue();
Contract.ThrowIfNull(metadata);
// don't use "Add" since key might already exist with already released metadata
_metadataCache [key] = newMetadata;
return(true);
}
}
public bool TryGetOrAddMetadata(FileKey key, ValueSource<AssemblyMetadata> newMetadata, out AssemblyMetadata metadata)
{
lock (_gate)
{
if (TryGetMetadata_NoLock(key, out metadata))
{
return false;
}
EnsureCapacity_NoLock();
metadata = newMetadata.GetValue();
Contract.ThrowIfNull(metadata);
// don't use "Add" since key might already exist with already released metadata
_metadataCache[key] = newMetadata;
return true;
}
}
private ModuleMetadata TryCreateModuleMetadataFromMetadataImporter(FileKey moduleFileKey)
{
IMetaDataInfo info;
IntPtr pImage;
long length;
if (!TryGetFileMappingFromMetadataImporter(moduleFileKey, out info, out pImage, out length))
{
return(null);
}
Contract.Requires(pImage != IntPtr.Zero, "Base address should not be zero if GetFileFlatMapping call succeeded.");
var metadata = ModuleMetadata.CreateFromImage(pImage, (int)length);
s_lifetimeMap.Add(metadata, info);
return(metadata);
}
private void Update(FileInfo file)
{
FileKey key = new FileKey(file);
List <RecentProject> list = new List <RecentProject>();
bool flagChanged = false;
if (!_recentProjects.ContainsKey(key))
{
_recentProjects.Add(key, new RecentProject(file));
flagChanged = true;
}
foreach (RecentProject rproject in _recentProjects.Values)
{
if (rproject.File.Exists)
{
list.Add(rproject);
}
}
RecentProject[] temp = list.ToArray();
list.Sort(CompareByTime);
_recentProjects.Clear();
for (int i = 0; i < list.Count; i++)
{
if (!flagChanged)
{
if (temp[i] != list[i])
{
flagChanged = true;
}
}
_recentProjects.Add(new FileKey(list[i].File), list[i]);
}
if (flagChanged)
{
this.UpdateMenuItem();
this.Save();
this.OnListChanged();
}
}
private void GetStorageInfoFromTemporaryStorage(FileKey moduleFileKey, out ITemporaryStreamStorage storage, out Stream stream, out IntPtr pImage)
{
int size;
using (var copyStream = SerializableBytes.CreateWritableStream())
{
// open a file and let it go as soon as possible
using (var fileStream = FileUtilities.OpenRead(moduleFileKey.FullPath))
{
var headers = new PEHeaders(fileStream);
var offset = headers.MetadataStartOffset;
size = headers.MetadataSize;
// given metadata contains no metadata info.
// throw bad image format exception so that we can show right diagnostic to user.
if (size <= 0)
{
throw new BadImageFormatException();
}
StreamCopy(fileStream, copyStream, offset, size);
}
// copy over the data to temp storage and let pooled stream go
storage = _temporaryStorageService.CreateTemporaryStreamStorage(CancellationToken.None);
copyStream.Position = 0;
storage.WriteStream(copyStream);
}
// get stream that owns direct access memory
stream = storage.ReadStream(CancellationToken.None);
// stream size must be same as what metadata reader said the size should be.
Contract.ThrowIfFalse(stream.Length == size);
// under VS host, direct access should be supported
var directAccess = (ISupportDirectMemoryAccess)stream;
pImage = directAccess.GetPointer();
}
public override void SaveData(StreamWriter writer, FileKey fk)
{
if (fk == FileKey.Primary)
{
foreach (GPCountry country in countries)
{
writer.WriteLine("{0}\t{1}", country.getCode(), country.getName());
}
}
else
{
foreach (GPCountry country in countries)
{
foreach (string timezoneName in country.Timezones)
{
writer.WriteLine("{0}\t{1}", country.getCode(), timezoneName);
}
}
}
}
public override void InsertNewObjectFromStrings(string[] parts, FileKey fk)
{
if (fk == FileKey.Primary)
{
if (parts.Length >= 2 && parts[0].Length > 0)
{
GPCountry location = new GPCountry();
location.setCode(parts[0]);
location.setName(parts[1]);
countries.Add(location);
}
}
else
{
if (parts.Length == 2)
{
addTimezone(parts[0], parts[1]);
}
}
}
private ModuleMetadata CreateModuleMetadataFromTemporaryStorage(FileKey moduleFileKey, List <ITemporaryStreamStorage> storages)
{
ITemporaryStreamStorage storage;
Stream stream;
IntPtr pImage;
GetStorageInfoFromTemporaryStorage(moduleFileKey, out storage, out stream, out pImage);
var metadata = ModuleMetadata.CreateFromMetadata(pImage, (int)stream.Length);
// first time, the metadata is created. tie lifetime.
s_lifetimeMap.Add(metadata, stream);
// hold onto storage if requested
if (storages != null)
{
storages.Add(storage);
}
return(metadata);
}
/// <exception cref="IOException"/>
/// <exception cref="BadImageFormatException" />
internal Metadata GetMetadata(string fullPath, DateTime snapshotTimestamp)
{
var key = new FileKey(fullPath, snapshotTimestamp);
// check existing metadata
if (_metadataCache.TryGetMetadata(key, out var metadata))
{
return(metadata);
}
// use temporary storage
var storages = new List <ITemporaryStreamStorage> ();
var newMetadata = CreateAssemblyMetadataFromTemporaryStorage(key, storages);
// don't dispose assembly metadata since it shares module metadata
if (!_metadataCache.TryGetOrAddMetadata(key, new RecoverableMetadataValueSource(newMetadata, storages, lifetimeMap), out metadata))
{
newMetadata.Dispose();
}
return(metadata);
}
/// <exception cref="IOException"/>
/// <exception cref="BadImageFormatException" />
internal Metadata GetMetadata(string fullPath, DateTime snapshotTimestamp)
{
var key = new FileKey(fullPath, snapshotTimestamp);
// check existing metadata
AssemblyMetadata metadata;
if (_metadataCache.TryGetMetadata(key, out metadata))
{
return(metadata);
}
AssemblyMetadata newMetadata;
if (VsSmartScopeCandidate(key.FullPath) && TryGetAssemblyMetadataFromMetadataImporter(key, out newMetadata))
{
// don't dispose assembly metadata since it shares module metadata
if (!_metadataCache.TryGetOrAddMetadata(key, new WeakConstantValueSource <AssemblyMetadata>(newMetadata), out metadata))
{
newMetadata.Dispose();
}
return(metadata);
}
// use temporary storage
var storages = new List <ITemporaryStreamStorage>();
newMetadata = GetAssemblyMetadataFromTemporaryStorage(key, storages);
// don't dispose assembly metadata since it shares module metdata
if (!_metadataCache.TryGetOrAddMetadata(key, new RecoverableMetadataValueSource(newMetadata, storages, s_lifetimeMap), out metadata))
{
newMetadata.Dispose();
}
return(metadata);
}
static void Main(string[] args)
{
var config = BuildConfiguration();
var dbSettings = new SupplyDataContextSettings
{
ConnectionString = config.GetConnectionString("SqlDataConnection")
};
var provider = new ServiceCollection()
.AddEfSupplyContext(dbSettings).BuildServiceProvider();
var repo = provider.GetService <IInvoceRepository>();
//=====
var goods = new[]
{
GoodNumber.Parse("G4"),
GoodNumber.Parse("G2"),
GoodNumber.Parse("G6"),
GoodNumber.Parse("G6"),
GoodNumber.Parse("G6")
};
var invoce = new Invoce("34h-334", "AAA-2", goods);
var invoceList = new InvoceList(
InvoiceBarCode.Parse("CodeBI-1"),
FileKey.Parse("FK-1")
);
invoce.WhenListBeScan(invoceList);
repo.Save(invoce);
var invoces = repo.Query(0, 10, null);
}
public bool GetOrAddMetadata(FileKey key, ValueSource <Optional <AssemblyMetadata> > metadataSource, out AssemblyMetadata metadata)
{
lock (_gate)
{
if (TryGetMetadata_NoLock(key, out var cachedMetadata))
{
metadata = cachedMetadata;
return(false);
}
EnsureCapacity_NoLock();
var newMetadata = metadataSource.GetValueOrNull();
// the source is expected to keep the metadata alive at this point
Contract.ThrowIfNull(newMetadata);
// don't use "Add" since key might already exist with already released metadata
_metadataCache[key] = metadataSource;
metadata = newMetadata;
return(true);
}
}
public async Task UploadPackage(FileKey packageKey, Stream stream, CancellationToken cancellationToken)
{
var url = $"{ServerAddress}/api/upload/package";
var content = new StreamContent(stream, _BufferSize);
try
{
using (var formData = new MultipartFormDataContent())
{
formData.Add(content, "file", packageKey.Name);
formData.Headers.ContentMD5 = packageKey.Hash;
using (var response = await _client.PostAsync(url, formData, cancellationToken))
{
if (!response.IsSuccessStatusCode)
{
var errorMessage = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.RequestEntityTooLarge)
{
errorMessage = Resources.FileTooLarge;
}
throw new Exception(errorMessage);
}
}
}
}
catch (TaskCanceledException exc)
{
if (!exc.CancellationToken.IsCancellationRequested)
{
throw new Exception(Resources.UploadPackageTimeout, exc);
}
throw exc;
}
}
private ModuleMetadata CreateModuleMetadata(FileKey moduleFileKey, List<ITemporaryStreamStorage> storages)
{
var metadata = TryCreateModuleMetadataFromMetadataImporter(moduleFileKey);
if (metadata == null)
{
// getting metadata didn't work out through importer. fallback to shadow copy one
metadata = CreateModuleMetadataFromTemporaryStorage(moduleFileKey, storages);
}
return metadata;
}
private bool TryGetFileMappingFromMetadataImporter(FileKey fileKey, out IMetaDataInfo info, out IntPtr pImage, out long length)
{
// We might not be able to use COM services to get this if VS is shutting down. We'll synchronize to make sure this
// doesn't race against
using (_readerWriterLock.DisposableRead())
{
// here, we don't care about timestamp since all those bits should be part of Fx. and we assume that
// it won't be changed in the middle of VS running.
var fullPath = fileKey.FullPath;
info = default(IMetaDataInfo);
pImage = default(IntPtr);
length = default(long);
if (SmartOpenScopeServiceOpt == null)
{
return false;
}
var ppUnknown = default(object);
if (ErrorHandler.Failed(SmartOpenScopeServiceOpt.OpenScope(fullPath, (uint)CorOpenFlags.ReadOnly, s_IID_IMetaDataImport, out ppUnknown)))
{
return false;
}
info = ppUnknown as IMetaDataInfo;
if (info == null)
{
return false;
}
CorFileMapping mappingType;
return ErrorHandler.Succeeded(info.GetFileMapping(out pImage, out length, out mappingType)) && mappingType == CorFileMapping.Flat;
}
}
/// <exception cref="IOException"/>
/// <exception cref="BadImageFormatException" />
internal Metadata GetMetadata(string fullPath, DateTime snapshotTimestamp)
{
var key = new FileKey(fullPath, snapshotTimestamp);
// check existing metadata
AssemblyMetadata metadata;
if (_metadataCache.TryGetMetadata(key, out metadata))
{
return metadata;
}
AssemblyMetadata newMetadata;
if (VsSmartScopeCandidate(key.FullPath) && TryCreateAssemblyMetadataFromMetadataImporter(key, out newMetadata))
{
if (!_metadataCache.TryGetOrAddMetadata(key, new WeakConstantValueSource<AssemblyMetadata>(newMetadata), out metadata))
{
newMetadata.Dispose();
}
return metadata;
}
// use temporary storage
var storages = new List<ITemporaryStreamStorage>();
newMetadata = CreateAssemblyMetadataFromTemporaryStorage(key, storages);
// don't dispose assembly metadata since it shares module metadata
if (!_metadataCache.TryGetOrAddMetadata(key, new RecoverableMetadataValueSource(newMetadata, storages, s_lifetimeMap), out metadata))
{
newMetadata.Dispose();
}
return metadata;
}
/// <exception cref="IOException"/>
/// <exception cref="BadImageFormatException" />
private AssemblyMetadata CreateAssemblyMetadataFromTemporaryStorage(FileKey fileKey, List<ITemporaryStreamStorage> storages)
{
var moduleMetadata = CreateModuleMetadataFromTemporaryStorage(fileKey, storages);
return CreateAssemblyMetadata(fileKey, moduleMetadata, storages, CreateModuleMetadataFromTemporaryStorage);
}
private ModuleMetadata CreateModuleMetadataFromTemporaryStorage(FileKey moduleFileKey, List<ITemporaryStreamStorage> storages)
{
ITemporaryStreamStorage storage;
Stream stream;
IntPtr pImage;
GetStorageInfoFromTemporaryStorage(moduleFileKey, out storage, out stream, out pImage);
var metadata = ModuleMetadata.CreateFromMetadata(pImage, (int)stream.Length);
// first time, the metadata is created. tie lifetime.
s_lifetimeMap.Add(metadata, stream);
// hold onto storage if requested
if (storages != null)
{
storages.Add(storage);
}
return metadata;
}
private void GetStorageInfoFromTemporaryStorage(FileKey moduleFileKey, out ITemporaryStreamStorage storage, out Stream stream, out IntPtr pImage)
{
int size;
using (var copyStream = SerializableBytes.CreateWritableStream())
{
// open a file and let it go as soon as possible
using (var fileStream = FileUtilities.OpenRead(moduleFileKey.FullPath))
{
var headers = new PEHeaders(fileStream);
var offset = headers.MetadataStartOffset;
size = headers.MetadataSize;
// given metadata contains no metadata info.
// throw bad image format exception so that we can show right diagnostic to user.
if (size <= 0)
{
throw new BadImageFormatException();
}
StreamCopy(fileStream, copyStream, offset, size);
}
// copy over the data to temp storage and let pooled stream go
storage = _temporaryStorageService.CreateTemporaryStreamStorage(CancellationToken.None);
copyStream.Position = 0;
storage.WriteStream(copyStream);
}
// get stream that owns direct access memory
stream = storage.ReadStream(CancellationToken.None);
// stream size must be same as what metadata reader said the size should be.
Contract.ThrowIfFalse(stream.Length == size);
// under VS host, direct access should be supported
var directAccess = (ISupportDirectMemoryAccess)stream;
pImage = directAccess.GetPointer();
}
/// <exception cref="IOException"/>
/// <exception cref="BadImageFormatException" />
private bool TryCreateAssemblyMetadataFromMetadataImporter(FileKey fileKey, out AssemblyMetadata metadata)
{
metadata = default(AssemblyMetadata);
var manifestModule = TryCreateModuleMetadataFromMetadataImporter(fileKey);
if (manifestModule == null)
{
return false;
}
metadata = CreateAssemblyMetadata(fileKey, manifestModule, null, CreateModuleMetadata);
return true;
}
/// <exception cref="IOException"/>
/// <exception cref="BadImageFormatException" />
private AssemblyMetadata CreateAssemblyMetadata(
FileKey fileKey, ModuleMetadata manifestModule, List<ITemporaryStreamStorage> storages,
Func<FileKey, List<ITemporaryStreamStorage>, ModuleMetadata> moduleMetadataFactory)
{
ImmutableArray<ModuleMetadata>.Builder moduleBuilder = null;
string assemblyDir = null;
foreach (string moduleName in manifestModule.GetModuleNames())
{
if (moduleBuilder == null)
{
moduleBuilder = ImmutableArray.CreateBuilder<ModuleMetadata>();
moduleBuilder.Add(manifestModule);
assemblyDir = Path.GetDirectoryName(fileKey.FullPath);
}
var moduleFileKey = FileKey.Create(PathUtilities.CombineAbsoluteAndRelativePaths(assemblyDir, moduleName));
var metadata = moduleMetadataFactory(moduleFileKey, storages);
moduleBuilder.Add(metadata);
}
var modules = (moduleBuilder != null) ? moduleBuilder.ToImmutable() : ImmutableArray.Create(manifestModule);
return AssemblyMetadata.Create(modules);
}
private bool TryGetFileMappingFromMetadataImporter(FileKey fileKey, out IMetaDataInfo info, out IntPtr pImage, out long length)
{
// here, we don't care about timestamp since all those bits should be part of Fx. and we assume that
// it won't be changed in the middle of VS running.
var fullPath = fileKey.FullPath;
info = default(IMetaDataInfo);
pImage = default(IntPtr);
length = default(long);
var ppUnknown = default(object);
if (ErrorHandler.Failed(_smartOpenScopeService.OpenScope(fullPath, (uint)CorOpenFlags.ReadOnly, s_IID_IMetaDataImport, out ppUnknown)))
{
return false;
}
info = ppUnknown as IMetaDataInfo;
if (info == null)
{
return false;
}
CorFileMapping mappingType;
return ErrorHandler.Succeeded(info.GetFileMapping(out pImage, out length, out mappingType)) && mappingType == CorFileMapping.Flat;
}
private ModuleMetadata TryCreateModuleMetadataFromMetadataImporter(FileKey moduleFileKey)
{
IMetaDataInfo info;
IntPtr pImage;
long length;
if (!TryGetFileMappingFromMetadataImporter(moduleFileKey, out info, out pImage, out length))
{
return null;
}
Contract.Requires(pImage != IntPtr.Zero, "Base address should not be zero if GetFileFlatMapping call succeeded.");
var metadata = ModuleMetadata.CreateFromImage(pImage, (int)length);
s_lifetimeMap.Add(metadata, info);
return metadata;
}
