Malisa Ncube - C# and .NET Delights

/// <summary>

/// IPlugin Interface

/// Used by all the composable parts which will be used as plugins

/// </summary>

public interface IPlugin

{

}

/// <summary>

/// Plugin1

/// Example Plugin

/// </summary>

[Export(typeof(IPlugin))]

public partial class Plugin1 : UserControl, IPlugin

{

    public Plugin1()
    {
        InitializeComponent();
    }
}

/// <summary>
/// Form1
/// The main form. We need to have the [Export] attribute on it because on the Program.cs
/// we compose it using MEF and get its instance as an ExportedObject.
/// </summary>
[Export]
public partial class Form1 : Form
{
    /// <summary>
    /// Plugins
    /// These imports will be satisfied by instances of the IPlugin 's
    /// which in this case is the user controls with different colors.
    /// </summary>
    [Import]
    public IEnumerable<IPlugin> Plugins;

    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        // We loop through all the instances of the plugins an add them to the tableLayoutPanel
        // and because we know that all of them are UserControls we can cast the as Control.
        foreach (var plugin in Plugins)
        {
            (plugin as Control).Dock = DockStyle.Fill;
            tableLayoutPanel1.Controls.Add(plugin as Control);
        }
    }
}

static class Program
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);

        var form1 = Compose();
        Application.Run(form1);
    }

    public static Form1 Compose()
    {
        //Create a catalog - in this case we want to import the composable parts which exist in this
        //assembly, so we will use the AssemblyCatalog against the current assembly.
        //
        //It is also possible to import assemblies from external assemblies using the DirectoryCatalog.
        //Furthermore you can combine a number of catalogs into an AggregateCatalog.
        var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());

        //Create the Container - then pass the catalog into the container 
        var container = new CompositionContainer(catalog);

        //Return the instance of Form1.
        return container.GetExportedObject<Form1>();
    }
}

Program.cs

static class Program
{     

    static void Main()         
    {             
        Application.EnableVisualStyles();             
        Application.SetCompatibleTextRenderingDefault(false);             
        ....             
        ....                 
        Application.ApplicationExit += new EventHandler(Application_ApplicationExit);
        ....             
        ....         
    }          


static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e)
{
    Bug bug = Bug.Create();
    string screenshotFile = bug.CaptureScreenShot();

    bool sendScreenShot = false;
    bool bugSent = false;
    TaskDialog exceptionDialog = new TaskDialog();
    exceptionDialog.MainIcon = TaskDialogIcon.Error;
    exceptionDialog.MainInstruction = e.Exception.Message;
    exceptionDialog.UseCommandLinks = false;
    exceptionDialog.WindowTitle = "Error Occured!";
    exceptionDialog.Content = string.Format("Unhandled Exception: {0}\nSource: {1}\nObject: {2}", e.Exception.Message, e.Exception.Source, e.Exception.TargetSite.ToString());
    exceptionDialog.ExpandedByDefault = false;
    exceptionDialog.ExpandedInformation = e.Exception.StackTrace;

    exceptionDialog.VerificationText = "Do you want to send screenshot?";
    exceptionDialog.VerificationFlagChecked = true;
    exceptionDialog.FooterIcon = TaskDialogIcon.Information;

    TaskDialogButton sendButton = new TaskDialogButton();
    sendButton.ButtonId = 101;
    sendButton.ButtonText = "Send";

    TaskDialogButton cancelButton = new TaskDialogButton();
    cancelButton.ButtonId = 102;
    cancelButton.ButtonText = "Don't Send";

    exceptionDialog.Buttons = new TaskDialogButton[] { sendButton, cancelButton };
    int result = exceptionDialog.Show(null, out sendScreenShot);

    if (result == sendButton.ButtonId)
    {
        bug.BugUrl = "http://server:88/insert_bug.aspx";
        bug.MailText = string.Format("Unhandled Exception: {0}\nSource: {1}\nObject: {2}\nTrace: {3}", 
            e.Exception.Message, e.Exception.Source, e.Exception.TargetSite.ToString(), e.Exception.StackTrace);
        bug.ProjectId = "ICEA.NET";
        bug.UserName = "tester";
        bug.Password = "tester";
        bug.Subject = "User: [" + WindowsIdentity.GetCurrent().Name + "] "+ e.Exception.Message;

        if (sendScreenShot)
            bugSent = bug.WithAttachment(screenshotFile)
                         .ComposeMail()
                         .SendBugReport();
        else
            bugSent = bug.ComposeMail()
                         .SendBugReport();

        if (bugSent)
            MessageBox.Show("Details of error have sent to development team! Thanks.", "Message Sent", MessageBoxButtons.OK, MessageBoxIcon.Information);
        else
            MessageBox.Show("Could not send error details to development team!", "Message Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}


}

        public string ImageToBase64(Image image,  System.Drawing.Imaging.ImageFormat format)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                // Convert Image to byte[]
                image.Save(ms, format);
                byte[] imageBytes = ms.ToArray();

                // Convert byte[] to Base64 String
                string base64String = Convert.ToBase64String(imageBytes);
                return base64String;
            }
        }

        private string CaptureImage(Point SourcePoint, Point DestinationPoint, Rectangle SelectionRectangle)
        {
            using (Bitmap bitmap = new Bitmap(SelectionRectangle.Width, SelectionRectangle.Height))
            {
                using (Graphics g = Graphics.FromImage(bitmap))
                {
                    g.CopyFromScreen(SourcePoint, DestinationPoint, SelectionRectangle.Size);
                }
                //return the string which represent the image
                return ImageToBase64(bitmap, ImageFormat.Jpeg);
            }
        }

        public string CaptureScreenShot()
        {
            Rectangle bounds = Screen.GetBounds(Screen.GetBounds(Point.Empty));
            return CaptureImage(Point.Empty, Point.Empty, bounds);
        }

public Bug ComposeMail()
{
    mail = "&username=" + HttpUtility.UrlEncode(_UserName) +
           "&password=" + HttpUtility.UrlEncode(_Password) +
           "&from=" + HttpUtility.UrlEncode(_UserName) +
           "&short_desc=" + HttpUtility.UrlEncode(_Subject) +
           "&projectid=" + HttpUtility.UrlEncode(_ProjectId);

    if (_Attachment != string.Empty)
        mail += "&message=" + HttpUtility.UrlEncode(_Attachment);
    else
        mail += "&message=" + HttpUtility.UrlEncode(_MailText);

    return this;
}

public bool SendBugReport()
 {
     bool Success = false;
     ASCIIEncoding encoding = new ASCIIEncoding();
    

     byte[] buffer = encoding.GetBytes(mail);

     // Prepare web request...
     HttpWebRequest myRequest =
           (HttpWebRequest)WebRequest.Create(_BugUrl);

     // We use POST ( we can also use GET )

     myRequest.Method = "POST";

     // Set the content type to a FORM
     myRequest.ContentType = "application/x-www-form-urlencoded";
     myRequest.UserAgent = Application.ProductName;
     // Get length of content
     myRequest.ContentLength = buffer.Length;

     // Get request stream
     Stream newStream = myRequest.GetRequestStream();

     // Send the data.
     newStream.Write(buffer, 0, buffer.Length);

     // Close stream
     newStream.Close();


     // Assign the response object of 'HttpWebRequest' to a 'HttpWebResponse' variable.
     HttpWebResponse myHttpWebResponse = (HttpWebResponse)myRequest.GetResponse();

     // Display the contents of the page to the console.
     Stream streamResponse = myHttpWebResponse.GetResponseStream();

     // Get stream object
     StreamReader streamRead = new StreamReader(streamResponse);
     Char[] readBuffer = new Char[256];

     // Read from buffer
     int count = streamRead.Read(readBuffer, 0, 256);

     while (count > 0)
     {
         // get string
         String resultData = new String(readBuffer, 0, count);
         // Write the data
         Success = resultData.Contains("OK:");
         Console.WriteLine(resultData);
         // Read from buffer
         count = streamRead.Read(readBuffer, 0, 256);

     }
     // Release the response object resources.
     streamRead.Close();
     streamResponse.Close();

     // Close response
     myHttpWebResponse.Close();

     return Success;
 }