Synnefo » Pithos MS Client

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following 

// set of attributes. Change these attribute values to modify the information

// associated with an assembly.

[assembly: AssemblyTitle("NetSparkle")]

[assembly: AssemblyDescription("NetSparkle is an auto update framework for .NET developers")]

[assembly: AssemblyConfiguration("")]

[assembly: AssemblyCompany("Dirk Eisenberg")]

[assembly: AssemblyProduct("NetSparkle")]

[assembly: AssemblyCopyright("Copyright © Dirk Eisenberg 2010")]

[assembly: AssemblyTrademark("")]

[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible 

// to COM components.  If you need to access a type in this assembly from 

// COM, set the ComVisible attribute to true on that type.

[assembly: ComVisible(false)]

// The following GUID is for the ID of the typelib if this project is exposed to COM

[assembly: Guid("7891583a-a852-4093-9774-3518ed86c978")]

// Version information for an assembly consists of the following four values:

//

//      Major Version

//      Minor Version 

//      Build Number

//      Revision

//

// You can specify all the values or you can default the Build and Revision Numbers 

// by using the '*' as shown below:

// [assembly: AssemblyVersion("1.0.*")]

[assembly: AssemblyVersion("1.0.22")]

[assembly: AssemblyFileVersion("1.0.22")]

using System;

namespace AppLimit.NetSparkle.Interfaces

{

    interface INetSparkleAssemblyAccessor

    {

        string AssemblyCompany { get; }

        string AssemblyCopyright { get; }

        string AssemblyDescription { get; }

        string AssemblyProduct { get; }

        string AssemblyTitle { get; }

        string AssemblyVersion { get; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ComponentModel;

using System.Threading;

using System.Net;

using System.Windows.Forms;

using System.Drawing;

using System.Runtime.InteropServices;

using System.Management;

using System.Diagnostics;

using System.Security.Cryptography.X509Certificates;

using System.Net.Security;

namespace AppLimit.NetSparkle

{

    public delegate void LoopStartedOperation(Object sender);

    public delegate void LoopFinishedOperation(Object sender, Boolean UpdateRequired);

    /// <summary>

    /// Everytime when netsparkle detects an update the 

    /// consumer can decide what should happen as next with the help 

    /// of the UpdateDatected event

    /// </summary>

    public enum nNextUpdateAction

    {

        showStandardUserInterface = 1,

        performUpdateUnattended = 2,

        prohibitUpdate = 3

    }

    /// <summary>

    /// Contains all information for the update detected event

    /// </summary>

    public class UpdateDetectedEventArgs : EventArgs

    {

        public nNextUpdateAction NextAction;

        public NetSparkleConfiguration ApplicationConfig;

        public NetSparkleAppCastItem LatestVersion;        

    }

    /// <summary>

    /// This delegate will be used when an update was detected to allow library 

    /// consumer to add own user interface capabilities.    

    /// </summary>

    /// <param name="sender"></param>

    /// <param name="e"></param>

    public delegate void UpdateDetected(Object sender, UpdateDetectedEventArgs e);

    public class Sparkle : IDisposable

    {

        private BackgroundWorker _worker = new BackgroundWorker();

        private String _AppCastUrl;

        private String _AppReferenceAssembly;

        private Boolean _DoInitialCheck;

        private Boolean _ForceInitialCheck;

        private EventWaitHandle _exitHandle;

        private EventWaitHandle _loopingHandle;

        private NetSparkleMainWindows _DiagnosticWindow;

        private TimeSpan _CheckFrequency;

        /// <summary>

        /// Enables system profiling against a profile server

        /// </summary>

        public Boolean EnableSystemProfiling = false;

        /// <summary>

        /// Hides the release notes view when an update was found. This 

        /// mode is switched on automatically when no sparkle:releaseNotesLink

        /// tag was found in the app cast         

        /// </summary>

        public Boolean HideReleaseNotes = false;

        /// <summary>

        /// Contains the profile url for System profiling

        /// </summary>

        public Uri SystemProfileUrl;

        /// <summary>

        /// This event will be raised when a check loop will be started

        /// </summary>

        public event LoopStartedOperation checkLoopStarted;

        /// <summary>

        /// This event will be raised when a check loop is finished

        /// </summary>

        public event LoopFinishedOperation checkLoopFinished;

        /// <summary>

        /// This event can be used to override the standard user interface

        /// process when an update is detected

        /// </summary>

        public event UpdateDetected updateDetected;

        /// <summary>

        /// This property holds an optional application icon

        /// which will be displayed in the software update dialog. The icon has

        /// to be 48x48 pixels.

        /// </summary>

        public Image ApplicationIcon { get; set; }

        /// <summary>

        /// This property returns an optional application icon 

        /// which will displayed in the windows as self

        /// </summary>

        public Icon ApplicationWindowIcon { get; set; }

        /// <summary>

        /// This property enables a diagnostic window for debug reasons

        /// </summary>

        public Boolean ShowDiagnosticWindow { get; set; }

        /// <summary>

        /// This property enables the silent mode, this means 

        /// the application will be updated without user interaction

        /// </summary>

        public Boolean EnableSilentMode { get; set; }

        /// <summary>

        /// This property returns true when the upadete loop is running

        /// and files when the loop is not running

        /// </summary>

        public Boolean IsUpdateLoopRunning

        {

            get

            {

                return _loopingHandle.WaitOne(0);

            }

        }

        /// <summary>

        /// This property defines if we trust every ssl connection also when 

        /// this connection has not a valid cert

        /// </summary>

        public Boolean TrustEverySSLConnection { get; set; }      

        /// <summary>

        /// ctor which needs the appcast url

        /// </summary>

        /// <param name="appcastUrl"></param>

        public Sparkle(String appcastUrl)

            : this(appcastUrl, null)

        { }

        /// <summary>

        /// ctor which needs the appcast url and a referenceassembly

        /// </summary>

        public Sparkle(String appcastUrl, String referenceAssembly)

            : this(appcastUrl, referenceAssembly, false)

        { }

        /// <summary>

        /// ctor which needs the appcast url and a referenceassembly

        /// </summary>        

        public Sparkle(String appcastUrl, String referenceAssembly, Boolean ShowDiagnostic)

        {

            // preconfige ssl trust

            TrustEverySSLConnection = false;

            // configure ssl cert link

            ServicePointManager.ServerCertificateValidationCallback += RemoteCertificateValidation;

            // enable visual style to ensure that we have XP style or higher

            // also in WPF applications

            System.Windows.Forms.Application.EnableVisualStyles();

            // reset vars

            ApplicationIcon = null;

            _AppReferenceAssembly = null;            

            // set var

            ShowDiagnosticWindow = ShowDiagnostic;

            // create the diagnotic window

            _DiagnosticWindow = new NetSparkleMainWindows();

            // set the reference assembly

            if (referenceAssembly != null)

            {

                _AppReferenceAssembly = referenceAssembly;

                _DiagnosticWindow.Report("Checking the following file: " + _AppReferenceAssembly);

            }

            // show if needed

            ShowDiagnosticWindowIfNeeded();            

            // adjust the delegates

            _worker.WorkerReportsProgress = true;

            _worker.DoWork += new DoWorkEventHandler(_worker_DoWork);

            _worker.ProgressChanged += new ProgressChangedEventHandler(_worker_ProgressChanged);

            // build the wait handle

            _exitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);

            _loopingHandle = new EventWaitHandle(false, EventResetMode.ManualReset);

            // set the url

            _AppCastUrl = appcastUrl;

            _DiagnosticWindow.Report("Using the following url: " + _AppCastUrl);            

        }

        /// <summary>

        /// The method starts a NetSparkle background loop

        /// If NetSparkle is configured to check for updates on startup, proceeds to perform 

        /// the check. You should only call this function when your app is initialized and 

        /// shows its main window.        

        /// </summary>        

        /// <param name="doInitialCheck"></param>

        public void StartLoop(Boolean doInitialCheck)

        {

            StartLoop(doInitialCheck, false);

        }

        /// <summary>

        /// The method starts a NetSparkle background loop

        /// If NetSparkle is configured to check for updates on startup, proceeds to perform 

        /// the check. You should only call this function when your app is initialized and 

        /// shows its main window.

        /// </summary>

        /// <param name="doInitialCheck"></param>

        /// <param name="checkFrequency"></param>

        public void StartLoop(Boolean doInitialCheck, TimeSpan checkFrequency)

        {

            StartLoop(doInitialCheck, false, checkFrequency);

        }

        /// <summary>

        /// The method starts a NetSparkle background loop

        /// If NetSparkle is configured to check for updates on startup, proceeds to perform 

        /// the check. You should only call this function when your app is initialized and 

        /// shows its main window.

        /// </summary>

        /// <param name="doInitialCheck"></param>

        /// <param name="forceInitialCheck"></param>

        public void StartLoop(Boolean doInitialCheck, Boolean forceInitialCheck)

        {

            StartLoop(doInitialCheck, forceInitialCheck, TimeSpan.FromHours(24));

        }

        /// <summary>

        /// The method starts a NetSparkle background loop

        /// If NetSparkle is configured to check for updates on startup, proceeds to perform 

        /// the check. You should only call this function when your app is initialized and 

        /// shows its main window.

        /// </summary>

        /// <param name="doInitialCheck"></param>

        /// <param name="forceInitialCheck"></param>

        /// <param name="checkFrequency"></param>

        public void StartLoop(Boolean doInitialCheck, Boolean forceInitialCheck, TimeSpan checkFrequency)

        {

            // first set the event handle

            _loopingHandle.Set();

            // Start the helper thread as a background worker to 

            // get well ui interaction                        

            // show if needed

            ShowDiagnosticWindowIfNeeded();

            // store infos

            _DoInitialCheck = doInitialCheck;

            _ForceInitialCheck = forceInitialCheck;

            _CheckFrequency = checkFrequency;

            // create and configure the worker

            _DiagnosticWindow.Report("Starting background worker");

            // start the work

            _worker.RunWorkerAsync();

        }

        /// <summary>

        /// This method will stop the sparkle background loop and is called

        /// through the disposable interface automatically

        /// </summary>

        public void StopLoop()

        {

            // ensure the work will finished

            _exitHandle.Set();                       

        }

        /// <summary>

        /// Is called in the using context and will stop all background activities

        /// </summary>

        public void Dispose()

        {

            StopLoop();

        }

        /// <summary>

        /// This method updates the profile information which can be sended to the server if enabled    

        /// </summary>

        /// <param name="config"></param>

        public void UpdateSystemProfileInformation(NetSparkleConfiguration config)

        {

            // check if profile data is enabled

            if (!EnableSystemProfiling)

                return;

            // check if we need an update

            if (DateTime.Now - config.LastProfileUpdate < new TimeSpan(7, 0, 0, 0))

                return;

            // touch the profile update time

            config.TouchProfileTime();

            // start the profile thread

            Thread t = new Thread(ProfileDataThreadStart);

            t.Start(config);

        }

        /// <summary>

        /// Profile data thread

        /// </summary>

        /// <param name="obj"></param>

        private void ProfileDataThreadStart(object obj)

        {

            try

            {

                if (SystemProfileUrl != null)

                {

                    // get the config

                    NetSparkleConfiguration config = obj as NetSparkleConfiguration;

                    // collect data

                    NetSparkleDeviceInventory inv = new NetSparkleDeviceInventory(config);

                    inv.CollectInventory();

                    // build url

                    String requestUrl = inv.BuildRequestUrl(SystemProfileUrl.ToString() + "?");

                    HttpWebRequest.DefaultWebProxy = HttpWebRequest.GetSystemWebProxy();

                    // perform the webrequest

                    HttpWebRequest request = HttpWebRequest.Create(requestUrl) as HttpWebRequest;

                    using (WebResponse response = request.GetResponse())

                    {

                        // close the response 

                        response.Close();

                    }

                }

            }

            catch (Exception ex)

            {

                // No exception during data send 

                ReportDiagnosticMessage(ex.Message);

            }

        }

        /// <summary>

        /// This method checks if an update is required. During this process the appcast

        /// will be downloaded and checked against the reference assembly. Ensure that

        /// the calling process has access to the internet and read access to the 

        /// reference assembly. This method is also called from the background loops.

        /// </summary>

        /// <param name="config"></param>

        /// <returns></returns>

        public Boolean IsUpdateRequired(NetSparkleConfiguration config, out NetSparkleAppCastItem latestVersion)

        {

            // report

            ReportDiagnosticMessage("Downloading and checking appcast");

            // init the appcast

            NetSparkleAppCast cast = new NetSparkleAppCast(_AppCastUrl, config);

            // check if any updates are available

            try

            {

                latestVersion = cast.GetLatestVersion();

            }

            catch (Exception e)

            {

                // show the exeception message 

                ReportDiagnosticMessage("Error during app cast download: " + e.Message);

                // just null the version info

                latestVersion = null;

            }

            if (latestVersion == null)

            {

                ReportDiagnosticMessage("No version information in app cast found");

                return false;

            }

            else

            {

                ReportDiagnosticMessage("Lastest version on the server is " + latestVersion.Version);

            }

            // set the last check time

            ReportDiagnosticMessage("Touch the last check timestamp");

            config.TouchCheckTime();

            // check if the available update has to be skipped

            if (latestVersion.Version.Equals(config.SkipThisVersion))

            {

                ReportDiagnosticMessage("Latest update has to be skipped (user decided to skip version " + config.SkipThisVersion + ")");

                return false;

            }

            // check if the version will be the same then the installed version

            Version v1 = new Version(config.InstalledVersion);

            Version v2 = new Version(latestVersion.Version);

            if (v2 <= v1)

            {

                ReportDiagnosticMessage("Installed version is valid, no update needed (" + config.InstalledVersion + ")");

                return false;

            }

            // ok we need an update

            return true;

        }

        /// <summary>

        /// This method reads the local sparkle configuration for the given

        /// reference assembly

        /// </summary>

        /// <param name="AppReferenceAssembly"></param>

        /// <returns></returns>

        public NetSparkleConfiguration GetApplicationConfig()

        {

            NetSparkleConfiguration config;

            config = new NetSparkleConfiguration(_AppReferenceAssembly);

            return config;

        }

        /// <summary>

        /// This method shows the update ui and allows to perform the 

        /// update process

        /// </summary>

        /// <param name="currentItem"></param>

        public void ShowUpdateNeededUI(NetSparkleAppCastItem currentItem)

        {

            // create the form

            NetSparkleForm frm = new NetSparkleForm(currentItem, ApplicationIcon, ApplicationWindowIcon);

            // configure the form

            frm.TopMost = true;

            if (HideReleaseNotes)

                frm.RemoveReleaseNotesControls();

            // show it

            DialogResult dlgResult = frm.ShowDialog();

            if (dlgResult == DialogResult.No)

            {

                // skip this version

                NetSparkleConfiguration config = new NetSparkleConfiguration(_AppReferenceAssembly);

                config.SetVersionToSkip(currentItem.Version);

            }

            else if (dlgResult == DialogResult.Yes)

            {

                // download the binaries

                InitDownloadAndInstallProcess(currentItem);

            }

        }

        /// <summary>

        /// This method reports a message in the diagnostic window

        /// </summary>

        /// <param name="message"></param>

        public void ReportDiagnosticMessage(String message)

        {

            if (_DiagnosticWindow.InvokeRequired)

            {

                _DiagnosticWindow.Invoke(new Action<String>(ReportDiagnosticMessage), message);                

            }

            else

            {

                _DiagnosticWindow.Report(message);

            }

        }

        /// <summary>

        /// This method will be executed as worker thread

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        void _worker_DoWork(object sender, DoWorkEventArgs e)

        {

            // store the did run once feature

            Boolean goIntoLoop = true;

            Boolean checkTSP = true;

            Boolean doInitialCheck = _DoInitialCheck;

            Boolean isInitialCheck = true;

            // start our lifecycles

            do

            {

                // set state

                Boolean bUpdateRequired = false;

                // notify

                if (checkLoopStarted != null)

                    checkLoopStarted(this);

                // report status

                if (doInitialCheck == false)

                {

                    ReportDiagnosticMessage("Initial check prohibited, going to wait");

                    doInitialCheck = true;

                    goto WaitSection;

                }

                // report status

                ReportDiagnosticMessage("Starting update loop...");

                // read the config

                ReportDiagnosticMessage("Reading config...");

                NetSparkleConfiguration config = GetApplicationConfig();

                // calc CheckTasp

                Boolean checkTSPInternal = checkTSP;

                if (isInitialCheck && checkTSPInternal)

                    checkTSPInternal = !_ForceInitialCheck;

                // check if it's ok the recheck to software state

                if (checkTSPInternal)

                {

                    TimeSpan csp = DateTime.Now - config.LastCheckTime;

                    if (csp < _CheckFrequency)

                    {

                        ReportDiagnosticMessage(String.Format("Update check performed within the last {0} minutes!", _CheckFrequency.TotalMinutes));

                        goto WaitSection;

                    }

                }

                else

                    checkTSP = true;

                // when sparkle will be deactivated wait an other cycle

                if (config.CheckForUpdate == false)

                {

                    ReportDiagnosticMessage("Check for updates disabled");

                    goto WaitSection;

                }

                // update the runonce feature

                goIntoLoop = !config.DidRunOnce;

                // update profile information is needed

                UpdateSystemProfileInformation(config);

                // check if update is required

                NetSparkleAppCastItem latestVersion = null;

                bUpdateRequired = IsUpdateRequired(config, out latestVersion);

                if (!bUpdateRequired)

                    goto WaitSection;

                // show the update window

                ReportDiagnosticMessage("Update needed from version " + config.InstalledVersion + " to version " + latestVersion.Version);

                // send notification if needed

                UpdateDetectedEventArgs ev = new UpdateDetectedEventArgs() { NextAction = nNextUpdateAction.showStandardUserInterface, ApplicationConfig = config, LatestVersion = latestVersion };

                if (updateDetected != null)

                    updateDetected(this, ev);

                // check results

                switch(ev.NextAction)

                {

                    case nNextUpdateAction.performUpdateUnattended:

                        {

                            ReportDiagnosticMessage("Unattended update whished from consumer");

                            EnableSilentMode = true;

                            _worker.ReportProgress(1, latestVersion);

                            break;

                        }

                    case nNextUpdateAction.prohibitUpdate:

                        {

                            ReportDiagnosticMessage("Update prohibited from consumer");

                            break;

                        }

                    case nNextUpdateAction.showStandardUserInterface:

                    default:

                        {

                            ReportDiagnosticMessage("Standard UI update whished from consumer");

                            _worker.ReportProgress(1, latestVersion);

                            break;

                        }

                }                

            WaitSection:

                // reset initialcheck

                isInitialCheck = false;

                // notify

                if (checkLoopFinished != null)

                    checkLoopFinished(this, bUpdateRequired);

                // report wait statement

                ReportDiagnosticMessage(String.Format("Sleeping for an other {0} minutes, exit event or force update check event", _CheckFrequency.TotalMinutes));

                // wait for

                if (!goIntoLoop)

                    break;

                else

                {

                    // build the event array

                    WaitHandle[] handles = new WaitHandle[1];

                    handles[0] = _exitHandle;

                    // wait for any

                    int i = WaitHandle.WaitAny(handles, _CheckFrequency);

                    if (WaitHandle.WaitTimeout == i)

                    {

                        ReportDiagnosticMessage(String.Format("{0} minutes are over", _CheckFrequency.TotalMinutes));

                        continue;

                    }

                    // check the exit hadnle

                    if (i == 0)

                    {

                        ReportDiagnosticMessage("Got exit signal");

                        break;

                    }

                    // check an other check needed

                    if (i == 1)

                    {

                        ReportDiagnosticMessage("Got force update check signal");

                        checkTSP = false;

                        continue;

                    }

                }

            } while (goIntoLoop);

            // reset the islooping handle

            _loopingHandle.Reset();

        }

        /// <summary>

        /// This method will be notified

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void _worker_ProgressChanged(object sender, ProgressChangedEventArgs e)

        {

            switch (e.ProgressPercentage)

            {

                case 1:

                    {

                        // get the current item

                        NetSparkleAppCastItem currentItem = e.UserState as NetSparkleAppCastItem;

                        // show the update ui

                        if (EnableSilentMode == true)

                            InitDownloadAndInstallProcess(currentItem);

                        else

                            ShowUpdateNeededUI(currentItem);

                        break;

                    }

                case 0:

                    {

                        ReportDiagnosticMessage(e.UserState.ToString());

                        break;

                    }

            }

        }

        private void InitDownloadAndInstallProcess(NetSparkleAppCastItem item)

        {

            NetSparkleDownloadProgress dlProgress = new NetSparkleDownloadProgress(this, item, _AppReferenceAssembly, ApplicationIcon, ApplicationWindowIcon, EnableSilentMode);

            dlProgress.ShowDialog();

        }

        private void ShowDiagnosticWindowIfNeeded()

        {

            if (_DiagnosticWindow.InvokeRequired)

            {

                _DiagnosticWindow.Invoke(new Action(ShowDiagnosticWindowIfNeeded));

            }

            else

            {

                // check the diagnotic value

                NetSparkleConfiguration config = new NetSparkleConfiguration(_AppReferenceAssembly);

                if (config.ShowDiagnosticWindow || ShowDiagnosticWindow)

                {

                    Point newLocation = new Point();

                    newLocation.X = Screen.PrimaryScreen.Bounds.Width - _DiagnosticWindow.Width;

                    newLocation.Y = 0;

                    _DiagnosticWindow.Location = newLocation;

                    _DiagnosticWindow.Show();

                }

            }

        }

        private bool RemoteCertificateValidation(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)

        {

            if (TrustEverySSLConnection)

            {

                // verify if we talk about our app cast dll 

                HttpWebRequest req = sender as HttpWebRequest;

                if (req == null)

                    return (certificate is X509Certificate2) ? ((X509Certificate2)certificate).Verify() : false;

                // if so just return our trust 

                if (req.RequestUri.Equals(new Uri(_AppCastUrl)))

                    return true;

                else

                    return (certificate is X509Certificate2) ? ((X509Certificate2)certificate).Verify() : false;

            }

            else

            {

                // check our cert                 

                return (certificate is X509Certificate2) ? ((X509Certificate2)certificate).Verify() : false;

            }

        }

    }

}

<?xml version="1.0" encoding="utf-8"?>

<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

    <ProductVersion>9.0.30729</ProductVersion>

    <SchemaVersion>2.0</SchemaVersion>

    <ProjectGuid>{74635A21-2BAD-4522-AB95-E3E5703CD301}</ProjectGuid>

    <OutputType>Library</OutputType>

    <AppDesignerFolder>Properties</AppDesignerFolder>

    <RootNamespace>AppLimit.NetSparkle</RootNamespace>

    <AssemblyName>AppLimit.NetSparkle</AssemblyName>

    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>

    <FileAlignment>512</FileAlignment>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

    <DebugSymbols>true</DebugSymbols>

    <DebugType>full</DebugType>

    <Optimize>false</Optimize>

    <OutputPath>bin\Debug\</OutputPath>

    <DefineConstants>DEBUG;TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

    <DebugType>pdbonly</DebugType>

    <Optimize>true</Optimize>

    <OutputPath>bin\Release\</OutputPath>

    <DefineConstants>TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <ItemGroup>

    <Reference Include="System" />

    <Reference Include="System.Core">

      <RequiredTargetFramework>3.5</RequiredTargetFramework>

    </Reference>

    <Reference Include="System.Drawing" />

    <Reference Include="System.Management" />

    <Reference Include="System.Windows.Forms" />

    <Reference Include="System.Xml.Linq">

      <RequiredTargetFramework>3.5</RequiredTargetFramework>

    </Reference>

    <Reference Include="System.Data.DataSetExtensions">

      <RequiredTargetFramework>3.5</RequiredTargetFramework>

    </Reference>

    <Reference Include="System.Data" />

    <Reference Include="System.Xml" />

  </ItemGroup>

  <ItemGroup>

    <Compile Include="..\AssemblyInfo.cs">

      <Link>Properties\AssemblyInfo.cs</Link>

    </Compile>

    <Compile Include="NetSparkle.cs" />

    <Compile Include="NetSparkleAppCaseItem.cs" />

    <Compile Include="NetSparkleAppCast.cs" />

    <Compile Include="NetSparkleAssemblyAccessor.cs" />

    <Compile Include="NetSparkleConfiguration.cs" />

    <Compile Include="NetSparkleDeviceInventory.cs" />

    <Compile Include="NetSparkleDownloadProgress.cs">

      <SubType>Form</SubType>

    </Compile>

    <Compile Include="NetSparkleDownloadProgress.Designer.cs">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </Compile>

    <Compile Include="NetSparkleDSAVerificator.cs" />

    <Compile Include="NetSparkleForm.cs">

      <SubType>Form</SubType>

    </Compile>

    <Compile Include="NetSparkleForm.Designer.cs">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </Compile>

    <Compile Include="NetSparkleMainWindows.cs">

      <SubType>Form</SubType>

    </Compile>

    <Compile Include="NetSparkleMainWindows.Designer.cs">

      <DependentUpon>NetSparkleMainWindows.cs</DependentUpon>

    </Compile>

    <Compile Include="Properties\Resources.Designer.cs">

      <AutoGen>True</AutoGen>

      <DesignTime>True</DesignTime>

      <DependentUpon>Resources.resx</DependentUpon>

    </Compile>

  </ItemGroup>

  <ItemGroup>

    <EmbeddedResource Include="NetSparkleDownloadProgress.bg.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.de.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.es-MX.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.fr.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.it.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.lt.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.nl.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.pt-BR.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.ru.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.zh-CN.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.zh-TW.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.bg.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.de.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.es-MX.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.fr.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.it.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.lt.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.nl.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.pt-BR.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.ru.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.zh-CN.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.zh-TW.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleMainWindows.resx">

      <DependentUpon>NetSparkleMainWindows.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="Properties\Resources.resx">

      <Generator>ResXFileCodeGenerator</Generator>

      <LastGenOutput>Resources.Designer.cs</LastGenOutput>

    </EmbeddedResource>

  </ItemGroup>

  <ItemGroup>

    <None Include="ArtWork\software-update-available.png" />

  </ItemGroup>

  <ItemGroup>

    <Folder Include="Resources\" />

  </ItemGroup>

  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

       Other similar extension points exist, see Microsoft.Common.targets.

  <Target Name="BeforeBuild">

  </Target>

  <Target Name="AfterBuild">

  </Target>

  -->

</Project>

<?xml version="1.0" encoding="utf-8"?>

<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

    <ProductVersion>9.0.30729</ProductVersion>

    <SchemaVersion>2.0</SchemaVersion>

    <ProjectGuid>{74635A21-2BAD-4522-AB95-E3E5703CD301}</ProjectGuid>

    <OutputType>Library</OutputType>

    <AppDesignerFolder>Properties</AppDesignerFolder>

    <RootNamespace>AppLimit.NetSparkle</RootNamespace>

    <AssemblyName>AppLimit.NetSparkle.Net40</AssemblyName>

    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>

    <FileAlignment>512</FileAlignment>

    <FileUpgradeFlags>

    </FileUpgradeFlags>

    <OldToolsVersion>3.5</OldToolsVersion>

    <UpgradeBackupLocation />

    <TargetFrameworkProfile>Client</TargetFrameworkProfile>

    <PublishUrl>publish\</PublishUrl>

    <Install>true</Install>

    <InstallFrom>Disk</InstallFrom>

    <UpdateEnabled>false</UpdateEnabled>

    <UpdateMode>Foreground</UpdateMode>

    <UpdateInterval>7</UpdateInterval>

    <UpdateIntervalUnits>Days</UpdateIntervalUnits>

    <UpdatePeriodically>false</UpdatePeriodically>

    <UpdateRequired>false</UpdateRequired>

    <MapFileExtensions>true</MapFileExtensions>

    <ApplicationRevision>0</ApplicationRevision>

    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>

    <IsWebBootstrapper>false</IsWebBootstrapper>

    <UseApplicationTrust>false</UseApplicationTrust>

    <BootstrapperEnabled>true</BootstrapperEnabled>

    <SccProjectName>SAK</SccProjectName>

    <SccLocalPath>SAK</SccLocalPath>

    <SccAuxPath>SAK</SccAuxPath>

    <SccProvider>SAK</SccProvider>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

    <DebugSymbols>true</DebugSymbols>

    <DebugType>full</DebugType>

    <Optimize>false</Optimize>

    <OutputPath>Debug\lib\net40-full\</OutputPath>

    <DefineConstants>DEBUG;TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

    <DebugType>pdbonly</DebugType>

    <Optimize>true</Optimize>

    <OutputPath>Release\lib\net40-full\</OutputPath>

    <DefineConstants>TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <PropertyGroup>

    <SignAssembly>true</SignAssembly>

  </PropertyGroup>

  <PropertyGroup>

    <AssemblyOriginatorKeyFile>pithos.snk</AssemblyOriginatorKeyFile>

  </PropertyGroup>

  <ItemGroup>

    <Reference Include="System" />

    <Reference Include="System.Core">

      <RequiredTargetFramework>3.5</RequiredTargetFramework>

    </Reference>

    <Reference Include="System.Drawing" />

    <Reference Include="System.Management" />

    <Reference Include="System.Windows.Forms" />

    <Reference Include="System.Xml.Linq">

      <RequiredTargetFramework>3.5</RequiredTargetFramework>

    </Reference>

    <Reference Include="System.Data.DataSetExtensions">

      <RequiredTargetFramework>3.5</RequiredTargetFramework>

    </Reference>

    <Reference Include="System.Data" />

    <Reference Include="System.Xml" />

  </ItemGroup>

  <ItemGroup>

    <Compile Include="AssemblyInfo.cs" />

    <Compile Include="NetSparkleAssemblyReflectionAccessor.cs" />

    <Compile Include="Interfaces\INetSparkleAssemblyAccessor.cs" />

    <Compile Include="NetSparkle.cs" />

    <Compile Include="NetSparkleAppCaseItem.cs" />

    <Compile Include="NetSparkleAppCast.cs" />

    <Compile Include="NetSparkleAssemblyAccessor.cs" />

    <Compile Include="NetSparkleAssemblyDiagnosticsAccessor.cs" />

    <Compile Include="NetSparkleConfiguration.cs" />

    <Compile Include="NetSparkleDeviceInventory.cs" />

    <Compile Include="NetSparkleDownloadProgress.cs">

      <SubType>Form</SubType>

    </Compile>

    <Compile Include="NetSparkleDownloadProgress.Designer.cs">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </Compile>

    <Compile Include="NetSparkleDSAVerificator.cs" />

    <Compile Include="NetSparkleForm.cs">

      <SubType>Form</SubType>

    </Compile>

    <Compile Include="NetSparkleForm.Designer.cs">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </Compile>

    <Compile Include="NetSparkleMainWindows.cs">

      <SubType>Form</SubType>

    </Compile>

    <Compile Include="NetSparkleMainWindows.Designer.cs">

      <DependentUpon>NetSparkleMainWindows.cs</DependentUpon>

    </Compile>

    <Compile Include="Properties\Resources.Designer.cs">

      <AutoGen>True</AutoGen>

      <DesignTime>True</DesignTime>

      <DependentUpon>Resources.resx</DependentUpon>

    </Compile>

  </ItemGroup>

  <ItemGroup>

    <EmbeddedResource Include="NetSparkleDownloadProgress.bg.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.de.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.es-MX.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.fr.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.it.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.lt.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.nl.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.pt-BR.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.ru.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.zh-CN.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleDownloadProgress.zh-TW.resx">

      <DependentUpon>NetSparkleDownloadProgress.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.bg.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.de.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.es-MX.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.fr.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.it.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.lt.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.nl.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.pt-BR.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.ru.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.zh-CN.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleForm.zh-TW.resx">

      <DependentUpon>NetSparkleForm.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="NetSparkleMainWindows.resx">

      <DependentUpon>NetSparkleMainWindows.cs</DependentUpon>

    </EmbeddedResource>

    <EmbeddedResource Include="Properties\Resources.resx">

      <Generator>ResXFileCodeGenerator</Generator>

      <LastGenOutput>Resources.Designer.cs</LastGenOutput>

    </EmbeddedResource>

  </ItemGroup>

  <ItemGroup>

    <None Include="ArtWork\software-update-available.png" />

    <None Include="pithos.snk" />

  </ItemGroup>

  <ItemGroup>

    <Folder Include="Resources\" />

  </ItemGroup>

  <ItemGroup>

    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">

      <Visible>False</Visible>

      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>

      <Install>false</Install>

    </BootstrapperPackage>

    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">

      <Visible>False</Visible>

      <ProductName>.NET Framework 3.5 SP1</ProductName>

      <Install>true</Install>

    </BootstrapperPackage>

    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">

      <Visible>False</Visible>

      <ProductName>Windows Installer 3.1</ProductName>

      <Install>true</Install>

    </BootstrapperPackage>

  </ItemGroup>

  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

  <PropertyGroup>

    <PostBuildEvent>

    </PostBuildEvent>

  </PropertyGroup>

  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

       Other similar extension points exist, see Microsoft.Common.targets.

  <Target Name="BeforeBuild">

  </Target>

  <Target Name="AfterBuild">

  </Target>

  -->

</Project>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace AppLimit.NetSparkle

{

    public class NetSparkleAppCastItem : IComparable<NetSparkleAppCastItem>

    {

        public String AppName;

        public String AppVersionInstalled;

        public String Version;

        public String ReleaseNotesLink;

        public String DownloadLink;

        public String DSASignature;

        #region IComparable<NetSparkleAppCastItem> Members

        public int CompareTo(NetSparkleAppCastItem other)

        {

            Version v1 = new Version(this.Version);

            Version v2 = new Version(other.Version);

            return v1.CompareTo(v2);            

        }

        #endregion

    }    

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Xml;

using System.Net;

namespace AppLimit.NetSparkle

{

    public class NetSparkleAppCast

    {

        private NetSparkleConfiguration _config;

        private String _castUrl;

        private const String itemNode = "item";

        private const String enclosureNode = "enclosure";

        private const String releaseNotesLinkNode = "sparkle:releaseNotesLink";

        private const String versionAttribute = "sparkle:version";

        private const String dasSignature = "sparkle:dsaSignature";

        private const String urlAttribute = "url";

        public NetSparkleAppCast(String castUrl, NetSparkleConfiguration config)

        {

            _config     = config;

            _castUrl    = castUrl;

        }

        public NetSparkleAppCastItem GetLatestVersion()

        {

            NetSparkleAppCastItem latestVersion = null;

            // build a http web request stream

            WebRequest request = HttpWebRequest.Create(_castUrl);

            // request the cast and build the stream

            WebResponse response = request.GetResponse();

            Stream inputstream = response.GetResponseStream();

            NetSparkleAppCastItem currentItem = null;

            XmlTextReader reader = new XmlTextReader(inputstream);

            while(reader.Read())

            {

                if ( reader.NodeType == XmlNodeType.Element)

                {

                    switch(reader.Name)

                    {

                        case itemNode:

                            {

                                currentItem = new NetSparkleAppCastItem();

                                break;

                            }

                        case releaseNotesLinkNode:

                            {

                                currentItem.ReleaseNotesLink = reader.ReadString();

                                currentItem.ReleaseNotesLink = currentItem.ReleaseNotesLink.Trim('\n');

                                break;

                            }                            

                        case enclosureNode:

                            {

                                currentItem.Version = reader.GetAttribute(versionAttribute);

                                currentItem.DownloadLink = reader.GetAttribute(urlAttribute);

                                currentItem.DSASignature = reader.GetAttribute(dasSignature);

                                break;

                            }

                    }

                }

                else if (reader.NodeType == XmlNodeType.EndElement)

                {

                    switch (reader.Name)

                    {

                        case itemNode:

                            {

                                if (latestVersion == null)

                                    latestVersion = currentItem;

                                else if (currentItem.CompareTo(latestVersion) > 0 )

                                {

                                        latestVersion = currentItem;

                                }

                                break;

                            }                            

                    }

                }                    

            }

            // add some other attributes

            latestVersion.AppName = _config.ApplicationName;

            latestVersion.AppVersionInstalled = _config.InstalledVersion;

            // go ahead

            return latestVersion;

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Reflection;

using System.IO;

using AppLimit.NetSparkle.Interfaces;

namespace AppLimit.NetSparkle

{

    public class NetSparkleAssemblyAccessor : INetSparkleAssemblyAccessor

    {

        INetSparkleAssemblyAccessor _internalAccessor = null;

        public NetSparkleAssemblyAccessor(String assemblyName, Boolean bUseReflectionAccesor)

        {

            if ( bUseReflectionAccesor )

                _internalAccessor = new NetSparkleAssemblyReflectionAccessor(assemblyName);

            else

                _internalAccessor = new NetSparkleAssemblyDiagnosticsAccessor(assemblyName);

        }

        #region INetSparkleAssemblyAccessor Members

        public string AssemblyCompany

        {

            get { return _internalAccessor.AssemblyCompany; }

        }

        public string AssemblyCopyright

        {

            get { return _internalAccessor.AssemblyCopyright; }

        }

        public string AssemblyDescription

        {

            get { return _internalAccessor.AssemblyDescription; }

        }

        public string AssemblyProduct

        {

            get { return _internalAccessor.AssemblyProduct; }

        }

        public string AssemblyTitle

        {

            get { return _internalAccessor.AssemblyTitle; }

        }

        public string AssemblyVersion

        {

            get { return _internalAccessor.AssemblyVersion; }

        }

        #endregion

    }

}

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Reflection;

using System.IO;

using AppLimit.NetSparkle.Interfaces;

namespace AppLimit.NetSparkle

{

    public class NetSparkleAssemblyDiagnosticsAccessor : INetSparkleAssemblyAccessor

    {

        private string fileVersion;

        private string productVersion;

        private string productName;

        private string companyName;

        private string legalCopyright;

        private string fileDescription;

        public NetSparkleAssemblyDiagnosticsAccessor(String assemblyName)

        {

            if (assemblyName != null)

            {

                fileVersion = FileVersionInfo.GetVersionInfo(assemblyName).FileVersion;

                productVersion = FileVersionInfo.GetVersionInfo(assemblyName).ProductVersion;

                productName = FileVersionInfo.GetVersionInfo(assemblyName).ProductName;

                companyName = FileVersionInfo.GetVersionInfo(assemblyName).CompanyName;

                legalCopyright = FileVersionInfo.GetVersionInfo(assemblyName).LegalCopyright;

                fileDescription = FileVersionInfo.GetVersionInfo(assemblyName).FileDescription; 

            }

        }

        #region Assembly Attribute Accessors

        public string AssemblyTitle

        {

            get

            {

                return productName;                

            }

        }

        public string AssemblyVersion

        {

            get

            {

                return fileVersion;

            }

        }        

        public string AssemblyDescription

        {

            get { return fileDescription; }

        }

        public string AssemblyProduct

        {

            get

            {

                return productVersion;                                

            }