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; }
/// <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; }