/// <summary> /// Enumerates all types in the given assembly hunting for BizTalk types. /// </summary> /// <param name="assembly">Assembly to enumerate.</param> /// <returns>List of decompiled BizTalk artifacts.</returns> private static List <DecompiledArtifact> EnumerateAssembly(IAssembly assembly) { List <DecompiledArtifact> artifacts = new List <DecompiledArtifact>(); // Look at all types declared in this assembly and extract the BizTalk related ones if ((assembly != null) && (assembly.Modules != null)) { foreach (IModule module in assembly.Modules) { if (module.Types != null) { foreach (ITypeDeclaration typeDeclaration in module.Types) { // BizTalk artifacts are in sealed, non abstract classes if (!typeDeclaration.Interface && typeDeclaration.Sealed && !typeDeclaration.Abstract) { // Decompile the artifact DecompiledArtifact artifact = DecompileArtifact(typeDeclaration); if (artifact != null) { artifacts.Add(artifact); } } } } } } return(artifacts); }
/// <summary> /// Compute the destination path (a set of nested directories to mimic namespaces). /// The hierachy is also created on disk if it does not exist. /// </summary> /// <param name="basePath">Base path to start from.</param> /// <param name="artifact">Artifact to compute the export path for.</param> /// <returns>Path to the directory the artifact should be exported.</returns> private static string ComputeAndEnsureOutputPathHierachy(string basePath, DecompiledArtifact artifact) { // Compute the destiantion path (we start with the base path) string destinationPath = basePath; // Make sure the base path is available if (!Directory.Exists(basePath)) { Directory.CreateDirectory(basePath); } // Create directories as needed to mimic the namespace structure if (!String.IsNullOrEmpty(artifact.Namespace)) { string[] namespaces = artifact.Namespace.Split(new char[] { ',' }); if (namespaces != null) { foreach (string segment in namespaces) { destinationPath = Path.Combine(destinationPath, segment); if (!Directory.Exists(destinationPath)) { Directory.CreateDirectory(destinationPath); } } } } return(destinationPath); }
/// <summary> /// Notify the feedback area of an error during the export process. /// </summary> /// <param name="e">Exception.</param> /// <param name="artifact">Artifact being exported.</param> private void NotifyExportError(Exception e, DecompiledArtifact artifact) { // Update the progress bar progressBar.Increment(1); // Emit an error message to the feedback area string message = String.Format(CultureInfo.CurrentCulture, Resources.ErrorExportedArtifact, new object[] { artifact.ArtifactKind, artifact.Namespace + "." + artifact.Name, e.ToString() }); AppendMessageToFeedbackArea(message, System.Diagnostics.TraceLevel.Error); }
/// <summary> /// Notify the feedback area that we exported an artifact. /// </summary> /// <param name="outPath">Destination to where the artifact was exported.</param> /// <param name="artifact">Artifact exported.</param> private void NotifyArtifactExported(string outPath, DecompiledArtifact artifact) { // Update the progress bar progressBar.Increment(1); // Emit a message to the feedback area string message = String.Format(CultureInfo.CurrentCulture, Resources.ExportedArtifact, new object[] { artifact.ArtifactKind, artifact.Namespace + "." + artifact.Name, outPath }); AppendMessageToFeedbackArea(message, System.Diagnostics.TraceLevel.Info); }
/// <summary> /// Get the file extension associated with a given artifact. /// </summary> /// <param name="artifact">Artifact to consider when computing the extension.</param> /// <returns>Extension, as a string.</returns> private static string GetExtension(DecompiledArtifact artifact) { switch (artifact.ArtifactKind) { case Constants.BizTalkArtifactType.Map: return("xslt"); case Constants.BizTalkArtifactType.Orchestration: return("odx"); case Constants.BizTalkArtifactType.ReceivePipeline: case Constants.BizTalkArtifactType.SendPipeline: return("btp"); case Constants.BizTalkArtifactType.Schema: return("xsd"); default: return(String.Empty); } }
/// <summary> /// Decompiles a BizTalk type knowing its Reflector TypeDeclaration. /// </summary> /// <param name="typeDeclaration">Type declaration to decompile.</param> /// <returns>Decompiled Artifact.</returns> private static DecompiledArtifact DecompileArtifact(ITypeDeclaration typeDeclaration) { DecompiledArtifact artifact = null; // Build the fully qualified name of the base class for this type ITypeReference baseType = typeDeclaration.BaseType as ITypeReference; string fullyQualifiedTypeName = baseType.Name + ", " + baseType.Owner.ToString(); // Locate the class which will handle this artifact foreach (Constants.RecognizedBizTalkArtifact recognizedArtifact in Constants.RecognizedArtifacts) { // If we found a matching handler, create a new instance of the handler and initialize it if (String.CompareOrdinal(recognizedArtifact.ExpectedType, fullyQualifiedTypeName) == 0) { // Extract the XML representation of the artifact artifact = Activator.CreateInstance(recognizedArtifact.DecompiledType, new object[] { typeDeclaration }) as DecompiledArtifact; break; } } return(artifact); }
/// <summary> /// Handles the Click event fired by the "Decompile..." button. /// </summary> /// <param name="sender">Object sending this message.</param> /// <param name="e">Parameter associated with this event.</param> private void decompileButton_Click(object sender, EventArgs e) { // Compile the list of artifacts to export () List <DecompiledArtifact> artifactsToDecompile = new List <DecompiledArtifact>(); foreach (ListViewItem lvi in artifactsListView.CheckedItems) { DecompiledArtifact artifact = lvi.Tag as DecompiledArtifact; if (artifact != null) { artifactsToDecompile.Add(artifact); } } // Delegate the work to a popup dialog if (artifactsToDecompile.Count > 0) { using (ProgressDialog dialog = new ProgressDialog(artifactsToDecompile)) { dialog.ShowDialog(); } } }
/// <summary> /// Export the given artifact to a file under the given path. /// </summary> /// <param name="path">Path to export the artifact to.</param> /// <param name="artifact">Artifact to export.</param> private static void ExportFormattedXml(string path, DecompiledArtifact artifact) { // Construct the output file path string filePath = Path.ChangeExtension(Path.Combine(path, artifact.Name), GetExtension(artifact)); // Delete the file if it already exists if (File.Exists(filePath)) { File.Delete(filePath); } // Write the Xml and format it at the same time using (XmlTextWriter xmlWriter = new XmlTextWriter(filePath, System.Text.Encoding.UTF8)) { XmlDocument artifactDOM = new XmlDocument(); artifactDOM.LoadXml(artifact.ArtifactValue); // Configure the writer so it formats output xmlWriter.Formatting = Formatting.Indented; // Write to the output file artifactDOM.WriteTo(xmlWriter); } }