/// <summary> /// Writes the specified object representation of a manifest to XML. /// </summary> /// <param name="manifest">The object representation of the manifest.</param> /// <param name="path">The name of the output file.</param> public static void WriteManifest(Manifest manifest, string path) { using (Stream s = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.Write)) { WriteManifest(manifest, s); } }
/// <summary> /// Writes the specified object representation of a manifest to XML. /// The name of the output file is inferred from the SourcePath property of the manifest. /// </summary> /// <param name="manifest">The object representation of the manifest.</param> public static void WriteManifest(Manifest manifest) { string path = manifest.SourcePath; if (path == null) path = "manifest.xml"; WriteManifest(manifest, path); }
/// <summary> /// Writes the specified object representation of a manifest to XML. /// </summary> /// <param name="manifest">The object representation of the manifest.</param> /// <param name="path">The name of the output file.</param> /// <param name="targetframeWorkVersion">The target framework version.</param> public static void WriteManifest(Manifest manifest, string path, string targetframeWorkVersion) { using (Stream s = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.Write)) { WriteManifest(manifest, s, targetframeWorkVersion); } }
public static void WriteManifest(Manifest manifest) { string sourcePath = manifest.SourcePath; if (sourcePath == null) { sourcePath = "manifest.xml"; } WriteManifest(manifest, sourcePath); }
private static Stream Serialize(Manifest manifest) { manifest.OnBeforeSave(); MemoryStream stream = new MemoryStream(); XmlSerializer serializer = new XmlSerializer(manifest.GetType()); StreamWriter writer = new StreamWriter(stream); int tickCount = Environment.TickCount; serializer.Serialize((TextWriter) writer, manifest); Util.WriteLog(string.Format(CultureInfo.CurrentCulture, "ManifestWriter.Serialize t={0}", new object[] { Environment.TickCount - tickCount })); writer.Flush(); stream.Position = 0L; return stream; }
private static Stream Serialize(Manifest manifest) { manifest.OnBeforeSave(); MemoryStream m = new MemoryStream(); XmlSerializer s = new XmlSerializer(manifest.GetType()); StreamWriter w = new StreamWriter(m); int t1 = Environment.TickCount; s.Serialize(w, manifest); Util.WriteLog(String.Format(CultureInfo.CurrentCulture, "ManifestWriter.Serialize t={0}", Environment.TickCount - t1)); w.Flush(); m.Position = 0; return m; }
protected abstract bool OnManifestLoaded(Manifest manifest);
protected override bool OnManifestResolved(Manifest manifest) { return this.BuildResolvedSettings(manifest as DeployManifest); }
protected override bool OnManifestLoaded(Manifest manifest) { return this.BuildDeployManifest(manifest as DeployManifest); }
protected override bool OnManifestResolved(Manifest manifest) { if (UseApplicationTrust) return BuildResolvedSettings(manifest as ApplicationManifest); return true; }
protected override bool OnManifestLoaded(Manifest manifest) { return BuildApplicationManifest(manifest as ApplicationManifest); }
protected override bool OnManifestResolved (Manifest manifest) { throw new NotImplementedException (); }
public static void WriteManifest(Manifest manifest, Stream output) { int tickCount = Environment.TickCount; Stream s = Serialize(manifest); string fullName = manifest.AssemblyIdentity.GetFullName(AssemblyIdentity.FullNameFlags.All); if (string.IsNullOrEmpty(fullName)) { fullName = manifest.GetType().Name; } Util.WriteLogFile(fullName + ".write.0-serialized.xml", s); string resource = "write2.xsl"; Stream stream2 = null; if (manifest.GetType() == typeof(ApplicationManifest)) { ApplicationManifest manifest2 = (ApplicationManifest) manifest; if (manifest2.TrustInfo == null) { stream2 = XmlUtil.XslTransform(resource, s, new DictionaryEntry[0]); } else { string temporaryFile = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); manifest2.TrustInfo.Write(temporaryFile); if (Util.logging) { try { File.Copy(temporaryFile, Path.Combine(Util.logPath, fullName + ".trust-file.xml"), true); } catch (IOException) { } catch (ArgumentException) { } catch (UnauthorizedAccessException) { } catch (NotSupportedException) { } } DictionaryEntry entry = new DictionaryEntry("trust-file", temporaryFile); try { DictionaryEntry[] entries = new DictionaryEntry[] { entry }; stream2 = XmlUtil.XslTransform(resource, s, entries); } finally { File.Delete(temporaryFile); } } } else { stream2 = XmlUtil.XslTransform(resource, s, new DictionaryEntry[0]); } Util.WriteLogFile(fullName + ".write.1-transformed.xml", stream2); Stream stream3 = null; if (manifest.InputStream == null) { stream3 = stream2; } else { string str4 = Util.WriteTempFile(manifest.InputStream); DictionaryEntry entry2 = new DictionaryEntry("base-file", str4); try { DictionaryEntry[] entryArray2 = new DictionaryEntry[] { entry2 }; stream3 = XmlUtil.XslTransform("merge.xsl", stream2, entryArray2); } finally { File.Delete(str4); } Util.WriteLogFile(fullName + ".write.2-merged.xml", stream3); } Stream stream4 = ManifestFormatter.Format(stream3); Util.WriteLogFile(fullName + ".write.3-formatted.xml", stream4); Util.CopyStream(stream4, output); Util.WriteLog(string.Format(CultureInfo.CurrentCulture, "ManifestWriter.WriteManifest t={0}", new object[] { Environment.TickCount - tickCount })); }
public static void WriteManifest (Manifest manifest, Stream output) { throw new NotImplementedException (); }
protected abstract bool OnManifestResolved(Manifest manifest);
/// <summary> /// /// </summary> /// <param name="manifest"></param> /// <param name="output"></param> /// <param name="targetframeWorkVersion">it will always use sha256 as signature algorithm if TFV is null</param> private static void WriteManifest(Manifest manifest, Stream output, string targetframeWorkVersion) { int t1 = Environment.TickCount; Stream s1 = Serialize(manifest); string n = manifest.AssemblyIdentity.GetFullName(AssemblyIdentity.FullNameFlags.All); if (String.IsNullOrEmpty(n)) n = manifest.GetType().Name; Util.WriteLogFile(n + ".write.0-serialized.xml", s1); string resource = null; if (targetframeWorkVersion == null || targetframeWorkVersion.Length == 0 || Util.CompareFrameworkVersions(targetframeWorkVersion, Constants.TargetFrameworkVersion40) <= 0) { resource = "write2.xsl"; } else { resource = "write3.xsl"; } Stream s2 = null; if (manifest.GetType() == typeof(ApplicationManifest)) { ApplicationManifest am = (ApplicationManifest)manifest; if (am.TrustInfo == null) { s2 = XmlUtil.XslTransform(resource, s1); } else { // May throw IO-related exceptions string temp = FileUtilities.GetTemporaryFile(); am.TrustInfo.Write(temp); if (Util.logging) { try { File.Copy(temp, Path.Combine(Util.logPath, n + ".trust-file.xml"), true); } catch (IOException) { } catch (ArgumentException) { } catch (UnauthorizedAccessException) { } catch (NotSupportedException) { } } DictionaryEntry arg = new DictionaryEntry("trust-file", temp); try { s2 = XmlUtil.XslTransform(resource, s1, arg); } finally { File.Delete(temp); } } } else s2 = XmlUtil.XslTransform(resource, s1); Util.WriteLogFile(n + ".write.1-transformed.xml", s2); Stream s3 = null; if (manifest.InputStream == null) { s3 = s2; } else { string temp = Util.WriteTempFile(manifest.InputStream); DictionaryEntry arg = new DictionaryEntry("base-file", temp); try { s3 = XmlUtil.XslTransform("merge.xsl", s2, arg); } finally { File.Delete(temp); } Util.WriteLogFile(n + ".write.2-merged.xml", s3); } Stream s4 = ManifestFormatter.Format(s3); Util.WriteLogFile(n + ".write.3-formatted.xml", s4); Util.CopyStream(s4, output); Util.WriteLog(String.Format(CultureInfo.CurrentCulture, "ManifestWriter.WriteManifest t={0}", Environment.TickCount - t1)); }
/// <summary> /// Writes the specified object representation of a manifest to XML. /// </summary> /// <param name="manifest">The object representation of the manifest.</param> /// <param name="output">Specifies an output stream.</param> public static void WriteManifest(Manifest manifest, Stream output) { WriteManifest(manifest, output, null); }
public static void WriteManifest (Manifest manifest, string path) { throw new NotImplementedException (); }
private bool InitializeManifest(Type manifestType) { _startTime = Environment.TickCount; if (!ValidateInputs()) return false; if (manifestType == null) throw new ArgumentNullException("manifestType"); if (InputManifest == null || String.IsNullOrEmpty(InputManifest.ItemSpec)) { if (manifestType == typeof(ApplicationManifest)) _manifest = new ApplicationManifest(this.TargetFrameworkVersion); else if (manifestType == typeof(DeployManifest)) _manifest = new DeployManifest(this.TargetFrameworkMoniker); else throw new ArgumentException(String.Empty /* no message */, "manifestType"); } else { try { _manifest = ManifestReader.ReadManifest(manifestType.Name, InputManifest.ItemSpec, true); } catch (Exception ex) { Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", InputManifest.ItemSpec, ex.Message); return false; } } if (manifestType != _manifest.GetType()) { Log.LogErrorWithCodeFromResources("GenerateManifest.InvalidInputManifest"); return false; } if (_manifest is DeployManifest) { DeployManifest deployManifest = _manifest as DeployManifest; if (string.IsNullOrEmpty(deployManifest.TargetFrameworkMoniker)) deployManifest.TargetFrameworkMoniker = this.TargetFrameworkMoniker; } else if (_manifest is ApplicationManifest) { ApplicationManifest applicationManifest = _manifest as ApplicationManifest; if (string.IsNullOrEmpty(applicationManifest.TargetFrameworkVersion)) applicationManifest.TargetFrameworkVersion = this.TargetFrameworkVersion; } if (EntryPoint != null && !String.IsNullOrEmpty(EntryPoint.ItemSpec)) { AssemblyReferenceType referenceType = AssemblyReferenceType.Unspecified; if (_manifest is DeployManifest) referenceType = AssemblyReferenceType.ClickOnceManifest; if (_manifest is ApplicationManifest) referenceType = AssemblyReferenceType.ManagedAssembly; _manifest.EntryPoint = AddEntryPointFromItem(EntryPoint, referenceType); } if (Description != null) _manifest.Description = Description; return true; }
private bool InitializeManifest(Type manifestType) { this.startTime = Environment.TickCount; if (!this.ValidateInputs()) { return false; } if (manifestType == null) { throw new ArgumentNullException("manifestType"); } if ((this.InputManifest == null) || string.IsNullOrEmpty(this.InputManifest.ItemSpec)) { if (manifestType != typeof(ApplicationManifest)) { if (manifestType != typeof(DeployManifest)) { throw new ArgumentException(string.Empty, "manifestType"); } this.manifest = new DeployManifest(this.TargetFrameworkMoniker); } else { this.manifest = new ApplicationManifest(this.TargetFrameworkVersion); } } else { try { this.manifest = ManifestReader.ReadManifest(manifestType.Name, this.InputManifest.ItemSpec, true); } catch (Exception exception) { base.Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", new object[] { this.InputManifest.ItemSpec, exception.Message }); return false; } } if (manifestType != this.manifest.GetType()) { base.Log.LogErrorWithCodeFromResources("GenerateManifest.InvalidInputManifest", new object[0]); return false; } if (this.manifest is DeployManifest) { DeployManifest manifest = this.manifest as DeployManifest; if (string.IsNullOrEmpty(manifest.TargetFrameworkMoniker)) { manifest.TargetFrameworkMoniker = this.TargetFrameworkMoniker; } } else if (this.manifest is ApplicationManifest) { ApplicationManifest manifest2 = this.manifest as ApplicationManifest; if (string.IsNullOrEmpty(manifest2.TargetFrameworkVersion)) { manifest2.TargetFrameworkVersion = this.TargetFrameworkVersion; } } if ((this.EntryPoint != null) && !string.IsNullOrEmpty(this.EntryPoint.ItemSpec)) { AssemblyReferenceType unspecified = AssemblyReferenceType.Unspecified; if (this.manifest is DeployManifest) { unspecified = AssemblyReferenceType.ClickOnceManifest; } if (this.manifest is ApplicationManifest) { unspecified = AssemblyReferenceType.ManagedAssembly; } this.manifest.EntryPoint = this.AddEntryPointFromItem(this.EntryPoint, unspecified); } if (this.Description != null) { this.manifest.Description = this.Description; } return true; }