using System.Collections.Generic;

using System.Diagnostics;

using System.Threading;

/// <summary>

/// Потокобезопасный кэш

/// </summary>

/// <typeparam name="TKey">Тип ключа</typeparam>

/// <typeparam name="TValue">Тип значения</typeparam>

public sealed class Cache<TKey, TValue>

{

    /// <summary>

    /// Делегат для получения значения

    /// </summary>

    /// <param name="keyVal">ключ</param>

    /// <returns>значение</returns>

    public delegate TValue HowToObtainValue(TKey keyVal);

    /// <summary>

    /// Получение значения из кэша

    /// </summary>

    /// <param name="key">ключ</param>

    /// <returns></returns>

    public TValue Get(TKey key)

    {

        return Get(key, obtainer);

    }

    /// <summary>

    /// Получение значения из кэша

    /// </summary>

    /// <param name="key">ключ</param>

    /// <param name="howToObtainValue">делегат, используемый в случае 

    /// отсутсвия значения к кэше</param>

    /// <returns></returns>

    public TValue Get(TKey key, HowToObtainValue howToObtainValue)

    {

        rwl.AcquireReaderLock(Timeout.Infinite);

        try

        {

            TValue theValue;

            if(!dic.TryGetValue(key, out theValue))

            {

                LockCookie lc = rwl.UpgradeToWriterLock(Timeout.Infinite);

                try

                {

                    theValue = howToObtainValue(key);

                    dic.Add(key, theValue);

                }

                finally

                {

                    rwl.DowngradeFromWriterLock(ref lc);

                }

            }

            return theValue;

        }

        finally

        {

            rwl.ReleaseReaderLock();

        }

    }

    /// <summary>

    /// Констркутор

    /// </summary>

    /// <param name="underlyingDictionaryImplementation">реализация IDictionary</param>

    /// <param name="func">получение параметра</param>

    public Cache(    IDictionary<TKey,TValue> underlyingDictionaryImplementation, 

                    HowToObtainValue func)

    {

        dic = underlyingDictionaryImplementation;

        obtainer = func;

        rwl = new ReaderWriterLock();

    }

    public Cache(HowToObtainValue func)

        : this(new Dictionary<TKey, TValue>(), func)

    { }

    /// <summary>

    /// Конструктор по умолчанию

    /// </summary>

    public Cache():this(null)

    {}

    private ReaderWriterLock rwl;

    private IDictionary<TKey, TValue> dic;

    private HowToObtainValue obtainer;

    #if DEBUG

    /// <summary>

    /// !!! Пример использования !!!

    /// </summary>

    public static void Sample()

    {

        Cache<int, int> cache1 = new Cache<int, int>(

            delegate(int keyVal)

                {

                    Trace.WriteLine("Вычисляем для " + keyVal);

                    return keyVal*keyVal;

                }

            );

        for (int i = 1; i < 100; ++i)

        {

            Trace.WriteLine(cache1.Get(i));

        }

        for (int i = 1; i < 100; ++i)

        {

            Trace.WriteLine(cache1.Get(i));

        }

    }

    #endif

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Diagnostics;

using System.IO;

using System.Runtime.InteropServices;

using System.Text.RegularExpressions;

/// <summary>

/// SetupApi Wrapper class

/// Platform SDK: Setup API

/// </summary>

public sealed  class CabinetVersionProvider

{

    /// <summary>

    /// Получает версию из CAB-файла

    /// </summary>

    /// <param name="cabFilePath">Полный путь до CAB-файла</param>

    /// <returns>значение FileVersion из inf-файла CAB-а</returns>

    public static string GetVersion(string cabFilePath)

    {

        return getVersion(cabFilePath);

    }

    #region Тонкости реализации

    /// <summary>

    /// The FILE_IN_CABINET_INFO class provides information about a file found 

    /// in the cabinet.

    /// Platform SDK: Setup API 

    /// </summary>

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]

    private struct FILE_IN_CABINET_INFO

    {

        public String NameInCabinet;

        public uint FileSize;

        public uint Win32Error;

        public ushort DosDate;

        public ushort DosTime;

        public ushort DosAttribs;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]

        public String FullTargetName;

    }

    /// <summary>

    /// The FILEPATHS structure stores source and target path information. 

    /// Platform SDK: Setup API 

    /// </summary>

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]

    private struct FILEPATHS

    {

        public String Target;

        public String Source;

        public uint Win32Error;

        public uint Flags;

    }

    /// <summary>

    /// Platform SDK: Setup API

    /// </summary>

    private enum FILEOP : uint

    {

        FILEOP_ABORT = 0, // Abort cabinet processing.

        FILEOP_DOIT,    // Extract the current file.

        FILEOP_SKIP        // Skip the current file.

    }

    /// <summary>

    /// The FileCallback callback function is used by a number of the setup 

    /// functions. The PSP_FILE_CALLBACK type defines a pointer to this callback 

    /// function. FileCallback is a placeholder for the application-defined 

    /// function name.

    /// Platform SDK: Setup API

    /// </summary>

    private delegate uint PSP_FILE_CALLBACK(IntPtr context, 

                        uint notification, IntPtr param1, IntPtr param2);

    /// <summary>

    /// The file has been extracted from the cabinet.

    /// </summary>

    private const uint SPFILENOTIFY_FILEINCABINET = 0x00000011;    

    /// <summary>

    /// The current file is continued in the next cabinet.

    /// </summary>

    private const uint SPFILENOTIFY_FILEEXTRACTED = 0x00000013;

    private const uint NO_ERROR = 0;

    /// <summary>

    /// The SetupIterateCabinet function iterates through all the files in a 

    /// cabinet and sends a notification to a callback function for each 

    /// file found.

    /// Platform SDK: Setup API

    /// </summary>

    [DllImport("SetupApi.dll", CharSet = CharSet.Auto)]

    private static extern bool SetupIterateCabinet(string cabinetFile, 

                uint reserved, PSP_FILE_CALLBACK callBack, IntPtr context);

    [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]

    private static extern uint GetLastError();

    private static readonly Dictionary<string,string> m_cache = 

                                            new Dictionary<string, string>();

    private static string getVersion(string cabFilePath)

    {

        lock(m_cache)

        {

            string value;

            if(!m_cache.TryGetValue(cabFilePath, out value))

            {

                value = new CabinetVersionProvider(cabFilePath).m_version;

                value = string.IsNullOrEmpty(value) ? null : value;                    

                m_cache.Add(cabFilePath, value);

            }

            return value;

        }

    }

    private CabinetVersionProvider(string cabFileName)

    {

        m_version = null;

        m_tempfile = null;

        if (!SetupIterateCabinet(cabFileName, 0, callBack, IntPtr.Zero))

            throw new Win32Exception((int)GetLastError());

        if (m_tempfile != null)

        {

            string fileContent = File.ReadAllText(m_tempfile);

            MatchCollection mc = m_re.Matches(fileContent);

            if(mc.Count>0)

                m_version = mc[0].Groups[1].Captures[0].Value.Trim();

            try

            {

                File.Delete(m_tempfile);

            }

            catch(Exception err)

            {

                Trace.WriteLine(err);

            }

        }

    }

    private string m_version;

    private string m_tempfile;

    private static readonly Regex m_re = 

            new Regex(@"^\s*FileVersion\s*=\s*([^\s]+)\s*$",

                    RegexOptions.IgnoreCase

                        |RegexOptions.CultureInvariant

                        |RegexOptions.Multiline);

    private uint callBack(IntPtr context, uint notification,IntPtr param1, 

                                                            IntPtr param2)

    {

        switch(notification)

        {

            case SPFILENOTIFY_FILEINCABINET:

                if (m_tempfile != null)

                    return (uint)FILEOP.FILEOP_SKIP;

                FILE_IN_CABINET_INFO fileInCabinetInfo = 

                        (FILE_IN_CABINET_INFO)Marshal.PtrToStructure(

                                                            param1, 

                                                            typeof(FILE_IN_CABINET_INFO));

                if (fileInCabinetInfo.NameInCabinet.ToLower().EndsWith(".inf"))

                {

                    fileInCabinetInfo.FullTargetName = (m_tempfile = Path.GetTempFileName());

                    Marshal.StructureToPtr(fileInCabinetInfo, param1, true);

                    return (uint)FILEOP.FILEOP_DOIT;

                }

                else

                    return (uint)FILEOP.FILEOP_SKIP;

            case SPFILENOTIFY_FILEEXTRACTED:

                FILEPATHS filePaths =

                    (FILEPATHS)Marshal.PtrToStructure(param1, typeof(FILEPATHS));

                return filePaths.Win32Error;                    

            default:

                return NO_ERROR;                    

        }

    }

    #endregion

}