Gilma - GUI for the ILMerge Application Revised for .NET 4.0

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Xml.Serialization;
using System.ComponentModel;
using System.IO;
using System.Text;
using ILMerging;

namespace Gilma {
  [XmlInclude(typeof(StateFile))]
  
  public class StateFile {
    #region Enums

    public enum TargetType : uint {
      Auto = 0,
      Dll = 1,
      Exe = 2,
      WinExe = 3,
    }

    #endregion

    #region Contructors
    public StateFile() {
    }
    #endregion

    #region Fields

    private string outputFile = "";
    private string primaryAssembly = "";
    private string keyFile = "";
    private StringCollection otherAssemblies = new StringCollection();
    private bool includePdb = false;
    private bool myZeroPeKind = false;
    private TargetType type = TargetType.Auto;

    #endregion

    #region Properties

    public string OutputFile {
      get {
        return outputFile;
      }
      set {
        outputFile = value;
      }
    }

    public string PrimaryAssembly {
      get {
        return primaryAssembly;
      }
      set {
        primaryAssembly = value;
      }
    }

    public string KeyFile {
      get {
        return keyFile;
      }
      set {
        keyFile = value;
      }
    }

    public StringCollection OtherAssemblies {
      get {
        return otherAssemblies;
      }
      set {
        otherAssemblies = value;
      }
    }

    public bool ZeroPeKind {
      get {
        return myZeroPeKind;
      }
      set {
        myZeroPeKind = value;
      }
    }
	

    public TargetType Type {
      get {
        return type;
      }
      set {
        type = value;
      }
    }

    public bool IncludePdb {
      get {
        return includePdb;
      }
      set {
        includePdb = value;
      }
    }

    #endregion

    #region File Operation

    public void Save(string path) {
      TextWriter writer = new StreamWriter(path);
      XmlSerializer serializer = null;
      try {
        serializer = new XmlSerializer(typeof(StateFile));
      } catch ( Exception ex ) {
        ex.ToString();
      }
      try {
        serializer.Serialize(writer, this);
      } catch ( Exception ex ) {
        ex.ToString();
      }
      writer.Close();
    }

    public static StateFile Load(string filename) {
      StateFile stateFile = null;
      if ( File.Exists(filename) ) {
        TextReader reader = new StreamReader(filename);
        XmlSerializer y = new XmlSerializer(typeof(StateFile));
        stateFile = (StateFile)y.Deserialize(reader);
        reader.Close();
      } else {
        stateFile = new StateFile();
      }
      return stateFile;
    }
    #endregion

    #region Methods
    public bool ShouldSerializeOtherAssemblies() {
      return otherAssemblies.Count > 0;
    }

    public StringBuilder Merge() {
      ILMerge myMerge = new ILMerge();
      String[] myCollection = new String[this.otherAssemblies.Count + 1];
      myCollection[0] = this.primaryAssembly;
      int counter = 1;
      foreach ( string filename in this.otherAssemblies ) {
        myCollection[counter++] = filename;
      }
      switch ( this.type ) {
        case TargetType.Auto:
          myMerge.TargetKind = ILMerge.Kind.SameAsPrimaryAssembly;
          break;
        case TargetType.Dll:
          myMerge.TargetKind = ILMerge.Kind.Dll;
          break;
        case TargetType.Exe:
          myMerge.TargetKind = ILMerge.Kind.Exe;
          break;
        case TargetType.WinExe:
          myMerge.TargetKind = ILMerge.Kind.WinExe;
          break;
      }
      myMerge.SetInputAssemblies(myCollection);
      myMerge.OutputFile = this.outputFile;
      myMerge.AllowZeroPeKind = myZeroPeKind;
      myMerge.Log = true;
      if ( keyFile.Length > 0 )
        myMerge.KeyFile = keyFile;
      myMerge.LogFile = this.OutputFile.Remove(this.outputFile.Length - 4) + ".log";
      StringBuilder output = new StringBuilder();
      StreamReader myStream = null;
      string text;
      try {
        if ( File.Exists(myMerge.LogFile) ) {
          File.Delete(myMerge.LogFile);
        }
        myMerge.Merge();
        myStream = File.OpenText(myMerge.LogFile);
        do {
          text = myStream.ReadLine();
          output.Append(text);
          output.Append("\n");
        } while ( text != null );
        myStream.Close();
      } catch ( Exception e1 ) {
        output.Append("Error Occurred in processing\n" + e1.Message);
        if ( myStream != null )
          myStream.Close();
      }
      return output;
    }
    #endregion

  }
}