isolationinterop.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / Deployment / isolationinterop.cs / 1305376 / isolationinterop.cs

                            #if !ISOLATION_IN_MSCORLIB 
#define FEATURE_COMINTEROP
#endif

using System; 
using System.Collections;
using System.Runtime.InteropServices; 
using System.Runtime.Versioning; 
using System.Security;
 
using CMS=System.Deployment.Internal.Isolation.Manifest;

namespace System.Deployment.Internal.Isolation
{ 
#if FEATURE_COMINTEROP
    [StructLayout(LayoutKind.Sequential)] 
    internal struct BLOB : IDisposable 
    {
        [MarshalAs(UnmanagedType.U4)] public uint Size; 
        [MarshalAs(UnmanagedType.SysInt)] public IntPtr BlobData;

        [System.Security.SecuritySafeCritical]  // auto-generated
        public void Dispose() 
        {
            if (BlobData != IntPtr.Zero) 
            { 
                Marshal.FreeCoTaskMem(BlobData);
                BlobData = IntPtr.Zero; 
            }
        }
    }
 
    [StructLayout(LayoutKind.Sequential)]
    internal struct IDENTITY_ATTRIBUTE 
    { 
        [MarshalAs(UnmanagedType.LPWStr)] public string Namespace;
        [MarshalAs(UnmanagedType.LPWStr)] public string Name; 
        [MarshalAs(UnmanagedType.LPWStr)] public string Value;
    }

    [Flags] 
    internal enum STORE_ASSEMBLY_STATUS_FLAGS
    { 
        STORE_ASSEMBLY_STATUS_MANIFEST_ONLY     = 0x00000001, 
        STORE_ASSEMBLY_STATUS_PAYLOAD_RESIDENT  = 0x00000002,
        STORE_ASSEMBLY_STATUS_PARTIAL_INSTALL   = 0x00000004, 
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct STORE_ASSEMBLY 
    {
        public uint Status; 
        public IDefinitionIdentity DefinitionIdentity; 
        [MarshalAs(UnmanagedType.LPWStr)] public string ManifestPath;
        public ulong AssemblySize; 
        public ulong ChangeId;
    }

    [Flags] 
    internal enum STORE_ASSEMBLY_FILE_STATUS_FLAGS
    { 
        STORE_ASSEMBLY_FILE_STATUS_FLAG_PRESENT = 0x00000001, 
    }
 
    [StructLayout(LayoutKind.Sequential)]
    internal struct STORE_ASSEMBLY_FILE
    {
        public uint Size; 
        public uint Flags;
        [MarshalAs(UnmanagedType.LPWStr)] public string FileName; 
        public uint FileStatusFlags; 
    }
 
    [StructLayout(LayoutKind.Sequential)]
    internal struct STORE_CATEGORY
    {
        public IDefinitionIdentity DefinitionIdentity; 
    }
 
    [StructLayout(LayoutKind.Sequential)] 
    internal struct STORE_CATEGORY_SUBCATEGORY
    { 
        [MarshalAs(UnmanagedType.LPWStr)] public string Subcategory;
    }

    [StructLayout(LayoutKind.Sequential)] 
    internal struct STORE_CATEGORY_INSTANCE
    { 
        public IDefinitionAppId DefinitionAppId_Application; 
        [MarshalAs(UnmanagedType.LPWStr)] public string XMLSnippet;
    } 

    [StructLayout(LayoutKind.Sequential)]
    internal struct CATEGORY
    { 
        public IDefinitionIdentity DefinitionIdentity;
    } 
 
    [StructLayout(LayoutKind.Sequential)]
    internal struct CATEGORY_SUBCATEGORY 
    {
        [MarshalAs(UnmanagedType.LPWStr)] public string Subcategory;
    }
 
    [StructLayout(LayoutKind.Sequential)]
    internal struct CATEGORY_INSTANCE 
    { 
        public IDefinitionAppId DefinitionAppId_Application;
        [MarshalAs(UnmanagedType.LPWStr)] public string XMLSnippet; 
    }

    [ComImport]
    [Guid("d8b1aacb-5142-4abb-bcc1-e9dc9052a89e")] 
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface IEnumSTORE_ASSEMBLY_INSTALLATION_REFERENCE 
    { 
        [SecurityCritical]
        uint Next( 
            [In] uint celt,
            [Out, MarshalAs(UnmanagedType.LPArray)] StoreApplicationReference[] rgelt
            /*[Out, Optional] out uint Fetched*/
            ); 
        [SecurityCritical]
        void Skip([In] uint celt); 
        [SecurityCritical] 
        void Reset();
        [SecurityCritical] 
        IEnumSTORE_ASSEMBLY_INSTALLATION_REFERENCE Clone();
    }

    [ComImport] 
    [Guid("f9fd4090-93db-45c0-af87-624940f19cff")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    interface IEnumSTORE_DEPLOYMENT_METADATA 
    {
        [SecurityCritical] 
        uint Next(
            [In] uint celt,
            [Out, MarshalAs(UnmanagedType.LPArray)] IDefinitionAppId[] AppIds
            ); 

        [SecurityCritical] 
        void Skip([In] uint celt); 
        [SecurityCritical]
        void Reset(); 
        [SecurityCritical]
        IEnumSTORE_DEPLOYMENT_METADATA Clone();
    };
 
    internal class StoreDeploymentMetadataEnumeration : IEnumerator
    { 
        private IEnumSTORE_DEPLOYMENT_METADATA _enum = null; 
        bool _fValid = false;
        IDefinitionAppId _current; 

        [SecuritySafeCritical]
        public StoreDeploymentMetadataEnumeration(IEnumSTORE_DEPLOYMENT_METADATA pI)
        { 
            _enum = pI;
        } 
 
        private IDefinitionAppId GetCurrent()
        { 
            if (!_fValid)
                throw new InvalidOperationException();
            return _current;
        } 

        object IEnumerator.Current { get { return GetCurrent(); } } 
        public IDefinitionAppId Current { get { return GetCurrent(); } } 

        public IEnumerator GetEnumerator() { return this; } 

        [SecuritySafeCritical]
        public bool MoveNext()
        { 
            IDefinitionAppId[] next = new IDefinitionAppId[1];
            UInt32 fetched; 
            fetched=_enum.Next(1, next); 
            if (fetched == 1)
                _current = next[0]; 
            return (_fValid = (fetched == 1));
        }

        [SecuritySafeCritical] 
        public void Reset()
        { 
            _fValid = false; 
            _enum.Reset();
        } 
    }

    [ComImport]
    [Guid("5fa4f590-a416-4b22-ac79-7c3f0d31f303")] 
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface IEnumSTORE_DEPLOYMENT_METADATA_PROPERTY 
    { 
        [SecurityCritical]
        uint Next( 
            [In] uint celt,
            [Out, MarshalAs(UnmanagedType.LPArray)] StoreOperationMetadataProperty[] AppIds
            );
 
        [SecurityCritical]
        void Skip([In] uint celt); 
        [SecurityCritical] 
        void Reset();
        [SecurityCritical] 
        IEnumSTORE_DEPLOYMENT_METADATA_PROPERTY Clone();
    };

    internal class StoreDeploymentMetadataPropertyEnumeration : IEnumerator 
    {
        private IEnumSTORE_DEPLOYMENT_METADATA_PROPERTY _enum = null; 
        bool _fValid = false; 
        StoreOperationMetadataProperty _current;
 
        [SecuritySafeCritical]
        public StoreDeploymentMetadataPropertyEnumeration(IEnumSTORE_DEPLOYMENT_METADATA_PROPERTY pI)
        {
            _enum = pI; 
        }
 
        private StoreOperationMetadataProperty GetCurrent() 
        {
            if (!_fValid) 
                throw new InvalidOperationException();
            return _current;
        }
 
        object IEnumerator.Current { get { return GetCurrent(); } }
        public StoreOperationMetadataProperty Current { get { return GetCurrent(); } } 
 
        public IEnumerator GetEnumerator() { return this; }
 
        [SecuritySafeCritical]
        public bool MoveNext()
        {
            StoreOperationMetadataProperty[] next = new StoreOperationMetadataProperty[1]; 
            UInt32 fetched;
            fetched=_enum.Next(1, next); 
            if (fetched == 1) 
                _current = next[0];
            return (_fValid = (fetched == 1)); 
        }

        [SecuritySafeCritical]
        public void Reset() 
        {
            _fValid = false; 
            _enum.Reset(); 
        }
    } 

    //
    // Unmanaged and managed versions of assembly enumeration
    // 
    [ComImport]
    [Guid("a5c637bf-6eaa-4e5f-b535-55299657e33e")] 
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    interface IEnumSTORE_ASSEMBLY
    { 
        [SecurityCritical]
        uint Next(
            [In] UInt32 celt,
            [Out, MarshalAs(UnmanagedType.LPArray)] STORE_ASSEMBLY[] rgelt 
            /*[Out, Optional] UInt32 *pceltFetched*/
            ); 
        [SecurityCritical] 
        void Skip([In] UInt32 celt);
        [SecurityCritical] 
        void Reset();
        [SecurityCritical]
        IEnumSTORE_ASSEMBLY Clone();
    }; 

    internal class StoreAssemblyEnumeration : IEnumerator 
    { 
        private IEnumSTORE_ASSEMBLY _enum = null;
        bool _fValid = false; 
        STORE_ASSEMBLY _current;

        [SecuritySafeCritical]
        public StoreAssemblyEnumeration(IEnumSTORE_ASSEMBLY pI) 
        {
            _enum = pI; 
        } 

        private STORE_ASSEMBLY GetCurrent() 
        {
            if (!_fValid)
                throw new InvalidOperationException();
            return _current; 
        }
 
        object IEnumerator.Current { get { return GetCurrent(); } } 
        public STORE_ASSEMBLY Current { get { return GetCurrent(); } }
 
        public IEnumerator GetEnumerator() { return this; }

        [SecuritySafeCritical]
        public bool MoveNext() 
        {
            STORE_ASSEMBLY[] next = new STORE_ASSEMBLY[1]; 
            UInt32 fetched; 
            fetched=_enum.Next(1, next);
            if (fetched == 1) 
                _current = next[0];
            return (_fValid = (fetched == 1));
        }
 
        [SecuritySafeCritical]
        public void Reset() 
        { 
            _fValid = false;
            _enum.Reset(); 
        }
    }

 
    //
    // Enumerating the files in an assembly 
    // 
    [ComImport]
    [Guid("a5c6aaa3-03e4-478d-b9f5-2e45908d5e4f")] 
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface IEnumSTORE_ASSEMBLY_FILE
    {
        [SecurityCritical] 
        uint Next(
            [In] UInt32 celt, 
            [Out, MarshalAs(UnmanagedType.LPArray)] STORE_ASSEMBLY_FILE[] rgelt 
            /*[Out, Optional] UInt32 *pceltFetched*/
            ); 
        [SecurityCritical]
        void Skip([In] UInt32 celt);
        [SecurityCritical]
        void Reset(); 
        [SecurityCritical]
        IEnumSTORE_ASSEMBLY_FILE Clone(); 
    }; 

    internal class StoreAssemblyFileEnumeration : IEnumerator 
    {
        private IEnumSTORE_ASSEMBLY_FILE _enum = null;
        bool _fValid = false;
        STORE_ASSEMBLY_FILE _current; 

        [SecuritySafeCritical] 
        public StoreAssemblyFileEnumeration(IEnumSTORE_ASSEMBLY_FILE pI) 
        {
            _enum = pI; 
        }

        public IEnumerator GetEnumerator() { return this; }
 
        private STORE_ASSEMBLY_FILE GetCurrent()
        { 
            if (!_fValid) 
                throw new InvalidOperationException();
            return _current; 
        }

        object IEnumerator.Current { get { return GetCurrent(); } }
        public STORE_ASSEMBLY_FILE Current { get { return GetCurrent(); } } 

        [SecuritySafeCritical] 
        public bool MoveNext() 
        {
            STORE_ASSEMBLY_FILE[] next = new STORE_ASSEMBLY_FILE[1]; 
            UInt32 fetched;
            fetched=_enum.Next(1, next);
            if (fetched == 1)
                _current = next[0]; 
            return (_fValid = (fetched == 1));
        } 
 
        [SecuritySafeCritical]
        public void Reset() 
        {
            _fValid = false;
            _enum.Reset();
        } 
    }
 
 
    //
    // Managed and unmanaged store enumeration 
    //
    [ComImport]
    [Guid("b840a2f5-a497-4a6d-9038-cd3ec2fbd222")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    interface IEnumSTORE_CATEGORY
    { 
        [SecurityCritical] 
        uint Next(
            [In] uint celt, 
            [Out, MarshalAs(UnmanagedType.LPArray)] STORE_CATEGORY[] rgElements
            /*[Out] out uint Fetched*/
            );
 
        [SecurityCritical]
        void Skip([In] uint ulElements); 
        [SecurityCritical] 
        void Reset();
        [SecurityCritical] 
        IEnumSTORE_CATEGORY Clone();
    }

    internal class StoreCategoryEnumeration : IEnumerator 
    {
        private IEnumSTORE_CATEGORY _enum = null; 
        bool _fValid = false; 
        STORE_CATEGORY _current;
 
        [SecuritySafeCritical]
        public StoreCategoryEnumeration(IEnumSTORE_CATEGORY pI)
        {
            _enum = pI; 
        }
 
        public IEnumerator GetEnumerator() { return this; } 

        private STORE_CATEGORY GetCurrent() 
        {
            if (!_fValid)
                throw new InvalidOperationException();
            return _current; 
        }
 
        object IEnumerator.Current { get { return GetCurrent(); } } 
        public STORE_CATEGORY Current { get { return GetCurrent(); } }
 
        [SecuritySafeCritical]
        public bool MoveNext()
        {
            STORE_CATEGORY[] next = new STORE_CATEGORY[1]; 
            UInt32 fetched;
            fetched=_enum.Next(1, next); 
            if (fetched == 1) 
                _current = next[0];
            return (_fValid = (fetched == 1)); 
        }

        [SecuritySafeCritical]
        public void Reset() 
        {
            _fValid = false; 
            _enum.Reset(); 
        }
    } 

    //
    // Managed and unmanaged subcategory enumeration
    // 
    [ComImport]
    [Guid("19be1967-b2fc-4dc1-9627-f3cb6305d2a7")] 
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    interface IEnumSTORE_CATEGORY_SUBCATEGORY
    { 
        [SecurityCritical]
        uint Next(
            [In] uint celt,
            [Out, MarshalAs(UnmanagedType.LPArray)] STORE_CATEGORY_SUBCATEGORY[] rgElements 
            /*[Out] out uint Fetched*/
            ); 
        [SecurityCritical] 
        void Skip([In] uint ulElements);
        [SecurityCritical] 
        void Reset();
        [SecurityCritical]
        IEnumSTORE_CATEGORY_SUBCATEGORY Clone();
    } 

    internal class StoreSubcategoryEnumeration : IEnumerator 
    { 
        private IEnumSTORE_CATEGORY_SUBCATEGORY _enum = null;
        bool _fValid = false; 
        STORE_CATEGORY_SUBCATEGORY _current;

        [SecuritySafeCritical]
        public StoreSubcategoryEnumeration(IEnumSTORE_CATEGORY_SUBCATEGORY pI) 
        {
            _enum = pI; 
        } 

        public IEnumerator GetEnumerator() { return this; } 

        private STORE_CATEGORY_SUBCATEGORY GetCurrent()
        {
            if (!_fValid) 
                throw new InvalidOperationException();
            return _current; 
        } 

        object IEnumerator.Current { get { return GetCurrent(); } } 
        public STORE_CATEGORY_SUBCATEGORY Current { get { return GetCurrent(); } }

        [SecuritySafeCritical]
        public bool MoveNext() 
        {
            STORE_CATEGORY_SUBCATEGORY[] next = new STORE_CATEGORY_SUBCATEGORY[1]; 
            UInt32 fetched; 
            fetched=_enum.Next(1, next);
            if (fetched == 1) 
                _current = next[0];
            return (_fValid = (fetched == 1));
        }
 
        [SecuritySafeCritical]
        public void Reset() 
        { 
            _fValid = false;
            _enum.Reset(); 
        }
    }

    // 
    // Enumeration of instances as well
    // 
    [ComImport] 
    [Guid("5ba7cb30-8508-4114-8c77-262fcda4fadb")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    interface IEnumSTORE_CATEGORY_INSTANCE
    {
        [SecurityCritical]
        uint Next( 
            [In] uint ulElements,
            [Out, MarshalAs(UnmanagedType.LPArray)] STORE_CATEGORY_INSTANCE[] rgInstances 
            /*[Out] out uint Fetched*/ 
            );
        [SecurityCritical] 
        void Skip([In] uint ulElements);
        [SecurityCritical]
        void Reset();
        [SecurityCritical] 
        IEnumSTORE_CATEGORY_INSTANCE Clone();
    } 
 
    internal class StoreCategoryInstanceEnumeration : IEnumerator
    { 
        private IEnumSTORE_CATEGORY_INSTANCE _enum = null;
        bool _fValid = false;
        STORE_CATEGORY_INSTANCE _current;
 
        [SecuritySafeCritical]
        public StoreCategoryInstanceEnumeration(IEnumSTORE_CATEGORY_INSTANCE pI) 
        { 
            _enum = pI;
        } 

        public IEnumerator GetEnumerator() { return this; }

        private STORE_CATEGORY_INSTANCE GetCurrent() 
        {
            if (!_fValid) 
                throw new InvalidOperationException(); 
            return _current;
        } 

        object IEnumerator.Current { get { return GetCurrent(); } }
        public STORE_CATEGORY_INSTANCE Current { get { return GetCurrent(); } }
 
        [SecuritySafeCritical]
        public bool MoveNext() 
        { 
            STORE_CATEGORY_INSTANCE[] next = new STORE_CATEGORY_INSTANCE[1];
            UInt32 fetched; 
            fetched=_enum.Next(1, next);
            if (fetched == 1)
                _current = next[0];
            return (_fValid = (fetched == 1)); 
        }
 
        [SecuritySafeCritical] 
        public void Reset()
        { 
            _fValid = false;
            _enum.Reset();
        }
    } 

#if !ISOLATION_IN_MSCORLIB 
    internal sealed class ReferenceIdentity 
    {
        internal IReferenceIdentity _id = null; 

        internal ReferenceIdentity(IReferenceIdentity i)
        {
            if (i == null) 
                throw new ArgumentNullException();
 
            _id = i; 
        }
 
        string GetAttribute(string ns, string n) { return _id.GetAttribute(ns, n); }
        string GetAttribute(string n) { return _id.GetAttribute(null, n); }

        void SetAttribute(string ns, string n, string v) { _id.SetAttribute(ns, n, v); } 
        void SetAttribute(string n, string v) { SetAttribute(null, n, v); }
 
        void DeleteAttribute(string ns, string n) { SetAttribute(ns, n, null); } 
        void DeleteAttribute(string n) { SetAttribute(null, n, null); }
    } 
#endif // !ISOLATION_IN_MSCORLIB

    [ComImport]
    [Guid("6eaf5ace-7917-4f3c-b129-e046a9704766")] 
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface IReferenceIdentity 
    { 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.LPWStr)] 
        string GetAttribute(
            [In, MarshalAs(UnmanagedType.LPWStr)] string Namespace,
            [In, MarshalAs(UnmanagedType.LPWStr)] string Name
            ); 
        [SecurityCritical]
        void SetAttribute( 
            [In, MarshalAs(UnmanagedType.LPWStr)] string Namespace, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string Name,
            [In, MarshalAs(UnmanagedType.LPWStr)] string Value 
            );
        [SecurityCritical]
        IEnumIDENTITY_ATTRIBUTE EnumAttributes();
        [SecurityCritical] 
        IReferenceIdentity Clone(
            [In] IntPtr /*SIZE_T*/ cDeltas, 
            [In, MarshalAs(UnmanagedType.LPArray)] IDENTITY_ATTRIBUTE[] Deltas 
            );
    } 

    [ComImport]
    [Guid("587bf538-4d90-4a3c-9ef1-58a200a8a9e7")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    interface IDefinitionIdentity
    { 
        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.LPWStr)]
        string GetAttribute( 
            [In, MarshalAs(UnmanagedType.LPWStr)] string Namespace,
            [In, MarshalAs(UnmanagedType.LPWStr)] string Name
            );
        [SecurityCritical] 
        void SetAttribute(
            [In, MarshalAs(UnmanagedType.LPWStr)] string Namespace, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string Name, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string Value);
        [SecurityCritical] 
        IEnumIDENTITY_ATTRIBUTE EnumAttributes();
        [SecurityCritical]
        IDefinitionIdentity Clone(
            [In] IntPtr /*SIZE_T*/ cDeltas, 
            [In, MarshalAs(UnmanagedType.LPArray)] IDENTITY_ATTRIBUTE[] Deltas
            ); 
    } 

#if !ISOLATION_IN_MSCORLIB 
    internal sealed class DefinitionIdentity
    {
        internal IDefinitionIdentity _id = null;
 
        internal DefinitionIdentity(IDefinitionIdentity i)
        { 
            if (i == null) 
                throw new ArgumentNullException();
 
            _id = i;
        }

        string GetAttribute(string ns, string n) { return _id.GetAttribute(ns, n); } 
        string GetAttribute(string n) { return _id.GetAttribute(null, n); }
 
        void SetAttribute(string ns, string n, string v) { _id.SetAttribute(ns, n, v); } 
        void SetAttribute(string n, string v) { SetAttribute(null, n, v); }
 
        void DeleteAttribute(string ns, string n) { SetAttribute(ns, n, null); }
        void DeleteAttribute(string n) { SetAttribute(null, n, null); }
    }
#endif // !ISOLATION_IN_MSCORLIB 

    [ComImport] 
    [Guid("9cdaae75-246e-4b00-a26d-b9aec137a3eb")] 
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface IEnumIDENTITY_ATTRIBUTE 
    {
        [SecurityCritical]
        uint Next(
            [In] uint celt, 
            [Out, MarshalAs(UnmanagedType.LPArray)] IDENTITY_ATTRIBUTE[] rgAttributes
            /*[Out, Optional] out uint Written*/); 
 
        [SecurityCritical]
        IntPtr CurrentIntoBuffer( 
            [In] IntPtr /*SIZE_T*/ Available,
            [Out, MarshalAs(UnmanagedType.LPArray)] byte[] Data
            /*[out] SIZE_T *pcbUsed*/);
 
        [SecurityCritical]
        void Skip([In] uint celt); 
        [SecurityCritical] 
        void Reset();
        [SecurityCritical] 
        IEnumIDENTITY_ATTRIBUTE Clone();
    }

    [ComImport] 
    [Guid("f3549d9c-fc73-4793-9c00-1cd204254c0c")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    interface IEnumDefinitionIdentity 
    {
        [SecurityCritical] 
        uint Next(
            [In] uint celt,
            [Out, MarshalAs(UnmanagedType.LPArray)] IDefinitionIdentity[] DefinitionIdentity
            /*[Out] out uint Written*/); 
        [SecurityCritical]
        void Skip([In] uint celt); 
        [SecurityCritical] 
        void Reset();
        [SecurityCritical] 
        IEnumDefinitionIdentity Clone();
    }

#if !ISOLATION_IN_MSCORLIB 
    internal sealed class EnumDefinitionIdentity : IEnumerator
    { 
        private IEnumDefinitionIdentity _enum = null; 
        IDefinitionIdentity _current = null;
        IDefinitionIdentity[] _fetchList = new IDefinitionIdentity[1]; 

        internal EnumDefinitionIdentity(IEnumDefinitionIdentity e)
        {
            if (e == null) 
                throw new ArgumentNullException();
 
            _enum = e; 
        }
 
        private DefinitionIdentity GetCurrent() {
            if (_current == null)
                throw new InvalidOperationException();
            return new DefinitionIdentity(_current); 
        }
 
        object IEnumerator.Current { get { return GetCurrent(); } } 
        public DefinitionIdentity Current { get { return GetCurrent(); } }
 
        public IEnumerator GetEnumerator() { return this; }

        public bool MoveNext()
        { 
            if ((_enum.Next(1, _fetchList)) == 1)
            { 
                _current = _fetchList[0]; 
                return true;
            } 
            else
            {
                _current = null;
                return false; 
            }
        } 
 
        public void Reset()
        { 
            _current = null;
            _enum.Reset();
        }
    } 
#endif // !ISOLATION_IN_MSCORLIB
 
    [ComImport] 
    [Guid("b30352cf-23da-4577-9b3f-b4e6573be53b")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    interface IEnumReferenceIdentity
    {
        [SecurityCritical]
        uint Next( 
            [In] uint celt,
            [Out, MarshalAs(UnmanagedType.LPArray)] IReferenceIdentity[] ReferenceIdentity 
            /*[Out] out uint Written*/); 
        [SecurityCritical]
        void Skip(uint celt); 
        [SecurityCritical]
        void Reset();
        [SecurityCritical]
        IEnumReferenceIdentity Clone(); 
    }
 
#if !ISOLATION_IN_MSCORLIB 
    internal sealed class EnumReferenceIdentity : IEnumerator
    { 
        private IEnumReferenceIdentity _enum = null;
        IReferenceIdentity _current = null;
        IReferenceIdentity[] _fetchList = new IReferenceIdentity[1];
 
        internal EnumReferenceIdentity(IEnumReferenceIdentity e)
        { 
            _enum = e; 
        }
 
        private ReferenceIdentity GetCurrent() {
            if (_current == null)
                throw new InvalidOperationException();
            return new ReferenceIdentity(_current); 
        }
 
        object IEnumerator.Current { get { return GetCurrent(); } } 
        public ReferenceIdentity Current { get { return GetCurrent(); } }
 
        public IEnumerator GetEnumerator() { return this; }

        public bool MoveNext()
        { 
            if ((_enum.Next(1, _fetchList)) == 1)
            { 
                _current = _fetchList[0]; 
                return true;
            } 
            else
            {
                _current = null;
                return false; 
            }
        } 
 
        public void Reset()
        { 
            _current = null;
            _enum.Reset();
        }
    } 
#endif // !ISOLATION_IN_MSCORLIB
 
    [ComImport] 
    [Guid("d91e12d8-98ed-47fa-9936-39421283d59b")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    interface IDefinitionAppId
    {
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.LPWStr)] string get_SubscriptionId(); 
        void put_SubscriptionId([In, MarshalAs(UnmanagedType.LPWStr)] string Subscription);
        [SecurityCritical] 
        [ResourceExposure(ResourceScope.Machine)] 
        [return:MarshalAs(UnmanagedType.LPWStr)] string get_Codebase();
        [SecurityCritical] 
        [ResourceExposure(ResourceScope.Machine)]
        void put_Codebase([In, MarshalAs(UnmanagedType.LPWStr)] string CodeBase);
        [SecurityCritical]
        IEnumDefinitionIdentity EnumAppPath(); 
        [SecurityCritical]
        void SetAppPath([In] uint cIDefinitionIdentity, [In, MarshalAs(UnmanagedType.LPArray)] IDefinitionIdentity[] DefinitionIdentity); 
    } 

#if !ISOLATION_IN_MSCORLIB 
    internal sealed class DefinitionAppId
    {
        internal IDefinitionAppId _id = null;
 
        internal DefinitionAppId(IDefinitionAppId id)
        { 
            if (id == null) 
                throw new ArgumentNullException();
            _id = id; 
        }

        public string SubscriptionId
        { 
            get { return _id.get_SubscriptionId(); }
            set { _id.put_SubscriptionId(value); } 
        } 

        public string Codebase 
        {
            get { return _id.get_Codebase(); }
            set { _id.put_Codebase(value); }
        } 

        public EnumDefinitionIdentity AppPath 
        { 
            get { return new EnumDefinitionIdentity(_id.EnumAppPath()); }
        } 

        void SetAppPath(IDefinitionIdentity[] Ids)
        {
            _id.SetAppPath((uint)Ids.Length, Ids); 
        }
    } 
#endif // !ISOLATION_IN_MSCORLIB 

    [ComImport] 
    [Guid("054f0bef-9e45-4363-8f5a-2f8e142d9a3b")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface IReferenceAppId
    { 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.LPWStr)] string get_SubscriptionId(); 
        void put_SubscriptionId([In, MarshalAs(UnmanagedType.LPWStr)] string Subscription); 
        [SecurityCritical]
        [ResourceExposure(ResourceScope.Machine)] 
        [return:MarshalAs(UnmanagedType.LPWStr)] string get_Codebase();
        [ResourceExposure(ResourceScope.Machine)]
        void put_Codebase([In, MarshalAs(UnmanagedType.LPWStr)] string CodeBase);
        [SecurityCritical] 
        IEnumReferenceIdentity EnumAppPath();
    } 
 
#if !ISOLATION_IN_MSCORLIB
    internal sealed class ReferenceAppId 
    {
        internal IReferenceAppId _id = null;

        internal ReferenceAppId(IReferenceAppId id) 
        {
            if (id == null) 
                throw new ArgumentNullException(); 
            _id = id;
        } 

        public string SubscriptionId
        {
            get { return _id.get_SubscriptionId(); } 
            set { _id.put_SubscriptionId(value); }
        } 
 
        public string Codebase
        { 
            get { return _id.get_Codebase(); }
            set { _id.put_Codebase(value); }
        }
 
        public EnumReferenceIdentity AppPath
        { 
            get { return new EnumReferenceIdentity(_id.EnumAppPath()); } 
        }
    } 
#endif // !ISOLATION_IN_MSCORLIB

    internal enum IIDENTITYAUTHORITY_DEFINITION_IDENTITY_TO_TEXT_FLAGS
    { 
        IIDENTITYAUTHORITY_DEFINITION_IDENTITY_TO_TEXT_FLAG_CANONICAL = 0x00000001,
    } 
 
    internal enum IIDENTITYAUTHORITY_REFERENCE_IDENTITY_TO_TEXT_FLAGS
    { 
        IIDENTITYAUTHORITY_REFERENCE_IDENTITY_TO_TEXT_FLAG_CANONICAL = 0x00000001,
    }

    internal enum IIDENTITYAUTHORITY_DOES_DEFINITION_MATCH_REFERENCE_FLAGS 
    {
        IIDENTITYAUTHORITY_DOES_DEFINITION_MATCH_REFERENCE_FLAG_EXACT_MATCH_REQUIRED = 0x00000001, 
    } 

    [ComImport] 
    [Guid("261a6983-c35d-4d0d-aa5b-7867259e77bc")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    internal interface IIdentityAuthority
    { 
        [SecurityCritical]
        IDefinitionIdentity TextToDefinition( 
            [In] UInt32 Flags, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string Identity
            ); 
        [SecurityCritical]
        IReferenceIdentity TextToReference(
            [In] UInt32 Flags,
            [In, MarshalAs(UnmanagedType.LPWStr)] string Identity 
            );
        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.LPWStr)] 
        string DefinitionToText(
            [In] UInt32 Flags, 
            [In] IDefinitionIdentity DefinitionIdentity
            );
        [SecurityCritical]
        UInt32 DefinitionToTextBuffer( 
            [In] UInt32 Flags,
            [In] IDefinitionIdentity DefinitionIdentity, 
            [In] UInt32 BufferSize, 
            [Out, MarshalAs(UnmanagedType.LPArray)] char[] Buffer
            /*out UInt32 cchBufferRequired*/ 
            );
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.LPWStr)]
        string ReferenceToText( 
            [In] UInt32 Flags,
            [In] IReferenceIdentity ReferenceIdentity 
            ); 
        [SecurityCritical]
        UInt32 ReferenceToTextBuffer( 
            [In] UInt32 Flags,
            [In] IReferenceIdentity ReferenceIdentity,
            [In] UInt32 BufferSize,
            [Out, MarshalAs(UnmanagedType.LPArray)] char[] Buffer 
            /*out UInt32 cchBufferRequired*/
            ); 
        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.Bool)]
        bool AreDefinitionsEqual( 
            [In] UInt32 Flags,
            [In] IDefinitionIdentity Definition1,
            [In] IDefinitionIdentity Definition2
            ); 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.Bool)] 
        bool AreReferencesEqual( 
            [In] UInt32 Flags,
            [In] IReferenceIdentity Reference1, 
            [In] IReferenceIdentity Reference2
            );
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.Bool)] 
        bool AreTextualDefinitionsEqual(
            [In] UInt32 Flags, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string IdentityLeft, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string IdentityRight
            ); 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.Bool)]
        bool AreTextualReferencesEqual(
            [In] UInt32 Flags, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string IdentityLeft,
            [In, MarshalAs(UnmanagedType.LPWStr)] string IdentityRight 
            ); 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.Bool)] 
        bool DoesDefinitionMatchReference(
            [In] UInt32 Flags,
            [In] IDefinitionIdentity DefinitionIdentity,
            [In] IReferenceIdentity ReferenceIdentity 
            );
        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.Bool)] 
        bool DoesTextualDefinitionMatchTextualReference(
            [In] UInt32 Flags, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string Definition,
            [In, MarshalAs(UnmanagedType.LPWStr)] string Reference
            );
        [SecurityCritical] 
        UInt64 HashReference(
            [In] UInt32 Flags, 
            [In] IReferenceIdentity ReferenceIdentity 
            );
        [SecurityCritical] 
        UInt64 HashDefinition(
            [In] UInt32 Flags,
            [In] IDefinitionIdentity DefinitionIdentity
            ); 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.LPWStr)] 
        string GenerateDefinitionKey( 
            [In] UInt32 Flags,
            [In] IDefinitionIdentity DefinitionIdentity 
            );
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.LPWStr)]
        string GenerateReferenceKey( 
            [In] UInt32 Flags,
            [In] IReferenceIdentity ReferenceIdentity 
            ); 
        [SecurityCritical]
        IDefinitionIdentity CreateDefinition(); 
        [SecurityCritical]
        IReferenceIdentity CreateReference();
    }
 
    [Flags]
    internal enum IAPPIDAUTHORITY_ARE_DEFINITIONS_EQUAL_FLAGS 
    { 
        IAPPIDAUTHORITY_ARE_DEFINITIONS_EQUAL_FLAG_IGNORE_VERSION = 0x00000001,
    } 

    [Flags]
    internal enum IAPPIDAUTHORITY_ARE_REFERENCES_EQUAL_FLAGS
    { 
        IAPPIDAUTHORITY_ARE_REFERENCES_EQUAL_FLAG_IGNORE_VERSION = 0x00000001,
    } 
 
    [ComImport]
    [Guid("8c87810c-2541-4f75-b2d0-9af515488e23")] 
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    internal interface IAppIdAuthority
    {
        [SecurityCritical] 
        IDefinitionAppId TextToDefinition(
            [In] UInt32 Flags, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string Identity 
            );
        [SecurityCritical] 
        IReferenceAppId TextToReference(
            [In] UInt32 Flags,
            [In, MarshalAs(UnmanagedType.LPWStr)] string Identity
            ); 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.LPWStr)] 
        string DefinitionToText( 
            [In] UInt32 Flags,
            [In] IDefinitionAppId DefinitionAppId 
            );
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.LPWStr)]
        string ReferenceToText( 
            [In] UInt32 Flags,
            [In] IReferenceAppId ReferenceAppId 
            ); 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.Bool)] 
        bool AreDefinitionsEqual(
            [In] UInt32 Flags,
            [In] IDefinitionAppId Definition1,
            [In] IDefinitionAppId Definition2 
            );
        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.Bool)] 
        bool AreReferencesEqual(
            [In] UInt32 Flags, 
            [In] IReferenceAppId Reference1,
            [In] IReferenceAppId Reference2
            );
        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.Bool)]
        bool AreTextualDefinitionsEqual( 
            [In] UInt32 Flags, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string AppIdLeft,
            [In, MarshalAs(UnmanagedType.LPWStr)] string AppIdRight 
            );
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.Bool)]
        bool AreTextualReferencesEqual( 
            [In] UInt32 Flags,
            [In, MarshalAs(UnmanagedType.LPWStr)] string AppIdLeft, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string AppIdRight 
            );
        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.Bool)]
        bool DoesDefinitionMatchReference(
            [In] UInt32 Flags,
            [In] IDefinitionAppId DefinitionIdentity, 
            [In] IReferenceAppId ReferenceIdentity
            ); 
        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.Bool)]
        bool DoesTextualDefinitionMatchTextualReference( 
            [In] UInt32 Flags,
            [In, MarshalAs(UnmanagedType.LPWStr)] string Definition,
            [In, MarshalAs(UnmanagedType.LPWStr)] string Reference
            ); 
        [SecurityCritical]
        UInt64 HashReference( 
            [In] UInt32 Flags, 
            [In] IReferenceAppId ReferenceIdentity
            ); 
        [SecurityCritical]
        UInt64 HashDefinition(
            [In] UInt32 Flags,
            [In] IDefinitionAppId DefinitionIdentity 
            );
        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.LPWStr)] 
        string GenerateDefinitionKey(
            [In] UInt32 Flags, 
            [In] IDefinitionAppId DefinitionIdentity
            );
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.LPWStr)] 
        string GenerateReferenceKey(
            [In] UInt32 Flags, 
            [In] IReferenceAppId ReferenceIdentity 
            );
        [SecurityCritical] 
        IDefinitionAppId CreateDefinition();
        [SecurityCritical]
        IReferenceAppId CreateReference();
    } 

    [Flags] 
    internal enum ISTORE_BIND_REFERENCE_TO_ASSEMBLY_FLAGS 
    {
        ISTORE_BIND_REFERENCE_TO_ASSEMBLY_FLAG_FORCE_LIBRARY_SEMANTICS = 0x00000001, 
    }

    [Flags]
    internal enum ISTORE_ENUM_ASSEMBLIES_FLAGS 
    {
        ISTORE_ENUM_ASSEMBLIES_FLAG_LIMIT_TO_VISIBLE_ONLY   = 0x00000001, 
        ISTORE_ENUM_ASSEMBLIES_FLAG_MATCH_SERVICING         = 0x00000002, 
        ISTORE_ENUM_ASSEMBLIES_FLAG_FORCE_LIBRARY_SEMANTICS = 0x00000004,
    } 

    [Flags]
    internal enum ISTORE_ENUM_FILES_FLAGS
    { 
        ISTORE_ENUM_FILES_FLAG_INCLUDE_INSTALLED_FILES = 0x00000001,
        ISTORE_ENUM_FILES_FLAG_INCLUDE_MISSING_FILES   = 0x00000002, 
    } 

    // 
    // Operations available to the "transact" operation
    //
    [StructLayout(LayoutKind.Sequential)]
    internal struct StoreOperationStageComponent 
    {
        [MarshalAs(UnmanagedType.U4)] public UInt32 Size; 
        [MarshalAs(UnmanagedType.U4)] public OpFlags Flags; 
        [MarshalAs(UnmanagedType.Interface)] public IDefinitionAppId Application;
        [MarshalAs(UnmanagedType.Interface)] public IDefinitionIdentity Component; 
        [MarshalAs(UnmanagedType.LPWStr)] public string ManifestPath;

        [Flags]
        public enum OpFlags 
        {
            Nothing = 0 
        } 

        public enum Disposition 
        {
            Failed = 0,
            Installed = 1,
            Refreshed = 2, 
            AlreadyInstalled = 3
        } 
 
        public void Destroy() { }
 
        public StoreOperationStageComponent(IDefinitionAppId app, string Manifest)
            : this(app, null, Manifest)
        {
        } 

        [System.Security.SecuritySafeCritical]  // auto-generated 
        public StoreOperationStageComponent(IDefinitionAppId app, IDefinitionIdentity comp, string Manifest) 
        {
            Size = (UInt32)Marshal.SizeOf(typeof(StoreOperationStageComponent)); 
            Flags = OpFlags.Nothing;
            Application = app;
            Component = comp;
            ManifestPath = Manifest; 
        }
 
    } 

    [StructLayout(LayoutKind.Sequential)] 
    internal struct StoreOperationStageComponentFile
    {
        [MarshalAs(UnmanagedType.U4)] public UInt32 Size;
        [MarshalAs(UnmanagedType.U4)] public OpFlags Flags; 
        [MarshalAs(UnmanagedType.Interface)] public IDefinitionAppId Application;
        [MarshalAs(UnmanagedType.Interface)] public IDefinitionIdentity Component; 
        [MarshalAs(UnmanagedType.LPWStr)] public string ComponentRelativePath; 
        [MarshalAs(UnmanagedType.LPWStr)] public string SourceFilePath;
 
        [Flags]
        public enum OpFlags
        {
            Nothing = 0 
        }
 
        public enum Disposition 
        {
            Failed = 0, 
            Installed = 1,
            Refreshed = 2,
            AlreadyInstalled = 3
        } 

        public StoreOperationStageComponentFile(IDefinitionAppId App, string CompRelPath, string SrcFile) 
            : this(App, null, CompRelPath, SrcFile) 
        {
        } 

        [System.Security.SecuritySafeCritical]  // auto-generated
        public StoreOperationStageComponentFile(IDefinitionAppId App, IDefinitionIdentity Component, string CompRelPath, string SrcFile)
        { 
            Size = (UInt32)Marshal.SizeOf(typeof(StoreOperationStageComponentFile));
            Flags = OpFlags.Nothing; 
            this.Application = App; 
            this.Component = Component;
            this.ComponentRelativePath = CompRelPath; 
            this.SourceFilePath = SrcFile;
        }

        public void Destroy() { } 

 
    } 

 
    [StructLayout(LayoutKind.Sequential)]
    internal struct StoreApplicationReference
    {
        [MarshalAs(UnmanagedType.U4)] public UInt32 Size; 
        [MarshalAs(UnmanagedType.U4)] public RefFlags Flags;
        public System.Guid GuidScheme; 
        [MarshalAs(UnmanagedType.LPWStr)] public string Identifier; 
        [MarshalAs(UnmanagedType.LPWStr)] public string NonCanonicalData;
 
        [Flags]
        public enum RefFlags
        {
            Nothing = 0 
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated 
        public StoreApplicationReference(System.Guid RefScheme, string Id, string NcData)
        { 
            Size = (UInt32)Marshal.SizeOf(typeof(StoreApplicationReference));
            Flags = RefFlags.Nothing;
            GuidScheme = RefScheme;
            Identifier = Id; 
            NonCanonicalData = NcData;
        } 
 
        [System.Security.SecurityCritical]  // auto-generated
        public IntPtr ToIntPtr() 
        {
            IntPtr Reference = Marshal.AllocCoTaskMem(Marshal.SizeOf(this));
            Marshal.StructureToPtr(this, Reference, false);
            return Reference; 
        }
 
        [System.Security.SecurityCritical]  // auto-generated 
        public static void Destroy(IntPtr ip)
        { 
            if (ip != IntPtr.Zero)
            {
                Marshal.DestroyStructure(ip, typeof(StoreApplicationReference));
                Marshal.FreeCoTaskMem(ip); 
            }
        } 
    } 

 
    [StructLayout(LayoutKind.Sequential)]
    internal struct StoreOperationPinDeployment
    {
        [MarshalAs(UnmanagedType.U4)] public UInt32 Size; 
        [MarshalAs(UnmanagedType.U4)] public OpFlags Flags;
        [MarshalAs(UnmanagedType.Interface)] public IDefinitionAppId Application; 
        [MarshalAs(UnmanagedType.I8)] public Int64 ExpirationTime; 
        public IntPtr Reference;
 
        [Flags]
        public enum OpFlags
        {
            Nothing = 0, 
            NeverExpires = 0x1
        } 
 
        public enum Disposition
        { 
            Failed = 0,
            Pinned = 1
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public StoreOperationPinDeployment(IDefinitionAppId AppId, StoreApplicationReference Ref) 
        { 
            Size = (UInt32)Marshal.SizeOf(typeof(StoreOperationPinDeployment));
            Flags = OpFlags.NeverExpires; 
            Application = AppId;

            Reference = Ref.ToIntPtr();
            ExpirationTime = 0; 
        }
 
        public StoreOperationPinDeployment(IDefinitionAppId AppId, System.DateTime Expiry, StoreApplicationReference Ref) 
            : this(AppId, Ref)
        { 
            Flags |= OpFlags.NeverExpires;
            //
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        public void Destroy() 
        { 
            StoreApplicationReference.Destroy(Reference);
        } 
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct StoreOperationUnpinDeployment 
    {
        [MarshalAs(UnmanagedType.U4)] public UInt32 Size; 
        [MarshalAs(UnmanagedType.U4)] public OpFlags Flags; 
        [MarshalAs(UnmanagedType.Interface)] public IDefinitionAppId Application;
        public IntPtr Reference; 

        [Flags]
        public enum OpFlags
        { 
            Nothing = 0
        } 
 
        public enum Disposition
        { 
            Failed = 0,
            Unpinned = 1
        }
 

        [System.Security.SecuritySafeCritical]  // auto-generated 
        public StoreOperationUnpinDeployment(IDefinitionAppId app, StoreApplicationReference reference) 
        {
            Size = (UInt32)Marshal.SizeOf(typeof(StoreOperationUnpinDeployment)); 
            Flags = OpFlags.Nothing;
            Application = app;
            Reference = reference.ToIntPtr();
        } 

        [System.Security.SecurityCritical]  // auto-generated 
        public void Destroy() 
        {
            StoreApplicationReference.Destroy(Reference); 
        }
    }

    [StructLayout(LayoutKind.Sequential)] 
    internal struct StoreOperationInstallDeployment
    { 
        [MarshalAs(UnmanagedType.U4)] public UInt32 Size; 
        [MarshalAs(UnmanagedType.U4)] public OpFlags Flags;
        [MarshalAs(UnmanagedType.Interface)] public IDefinitionAppId Application; 
        public IntPtr Reference;

        [Flags]
        public enum OpFlags 
        {
            Nothing = 0, 
            UninstallOthers = 0x1 
        }
 
        public enum Disposition
        {
            Failed = 0,
            AlreadyInstalled = 1, 
            Installed = 2,
        } 
 

        public StoreOperationInstallDeployment(IDefinitionAppId App, StoreApplicationReference reference) : 
            this(App, true, reference)
        {
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public StoreOperationInstallDeployment(IDefinitionAppId App, bool UninstallOthers, StoreApplicationReference reference) 
        { 
            Size = (UInt32)Marshal.SizeOf(typeof(StoreOperationInstallDeployment));
            Flags = OpFlags.Nothing; 
            Application = App;

            if (UninstallOthers)
            { 
                Flags |= OpFlags.UninstallOthers;
            } 
 
            Reference = reference.ToIntPtr();
        } 

        [System.Security.SecurityCritical]  // auto-generated
        public void Destroy()
        { 
            StoreApplicationReference.Destroy(Reference);
        } 
    } 

    [StructLayout(LayoutKind.Sequential)] 
    internal struct StoreOperationUninstallDeployment
    {
        [MarshalAs(UnmanagedType.U4)] public UInt32 Size;
        [MarshalAs(UnmanagedType.U4)] public OpFlags Flags; 
        [MarshalAs(UnmanagedType.Interface)] public IDefinitionAppId Application;
        public IntPtr Reference; 
 
        [Flags]
        public enum OpFlags 
        {
            Nothing = 0
        }
 
        public enum Disposition
        { 
            Failed = 0, 
            DidNotExist = 1,
            Uninstalled = 2 
        }


        [System.Security.SecuritySafeCritical]  // auto-generated 
        public StoreOperationUninstallDeployment(IDefinitionAppId appid, StoreApplicationReference AppRef)
        { 
            Size = (UInt32)Marshal.SizeOf(typeof(StoreOperationUninstallDeployment)); 
            Flags = OpFlags.Nothing;
            Application = appid; 
            Reference = AppRef.ToIntPtr();
        }

        [System.Security.SecurityCritical]  // auto-generated 
        public void Destroy()
        { 
            StoreApplicationReference.Destroy(Reference); 
        }
    } 

    [StructLayout(LayoutKind.Sequential)]
    internal struct StoreOperationMetadataProperty
    { 
        public System.Guid GuidPropertySet;
        [MarshalAs(UnmanagedType.LPWStr)] public string Name; 
        [MarshalAs(UnmanagedType.SysUInt)] public IntPtr ValueSize; 
        [MarshalAs(UnmanagedType.LPWStr)] public string Value;
 
        public StoreOperationMetadataProperty(System.Guid PropertySet, string Name)
            : this(PropertySet, Name, null)
        {
        } 

        public StoreOperationMetadataProperty(System.Guid PropertySet, string Name, string Value) 
        { 
            this.GuidPropertySet = PropertySet;
            this.Name = Name; 
            this.Value = Value;
            this.ValueSize = (Value != null) ? new IntPtr((Value.Length + 1) * 2) : IntPtr.Zero;
        }
    } 

    [StructLayout(LayoutKind.Sequential)] 
    internal struct StoreOperationSetDeploymentMetadata 
    {
        [MarshalAs(UnmanagedType.U4)] public UInt32 Size; 
        [MarshalAs(UnmanagedType.U4)] public OpFlags Flags;
        [MarshalAs(UnmanagedType.Interface)] public IDefinitionAppId Deployment;
        [MarshalAs(UnmanagedType.SysInt)] public IntPtr InstallerReference;
        [MarshalAs(UnmanagedType.SysInt)] public IntPtr /*SIZE_T*/ cPropertiesToTest; 
        [MarshalAs(UnmanagedType.SysInt)] public IntPtr PropertiesToTest;
        [MarshalAs(UnmanagedType.SysInt)] public IntPtr /*SIZE_T*/ cPropertiesToSet; 
        [MarshalAs(UnmanagedType.SysInt)] public IntPtr PropertiesToSet; 

        [Flags] 
        public enum OpFlags
        {
            Nothing = 0,
        } 

        public enum Disposition 
        { 
            Failed = 0,
            Set = 2 
        }

        public StoreOperationSetDeploymentMetadata(IDefinitionAppId Deployment, StoreApplicationReference Reference, StoreOperationMetadataProperty[] SetProperties)
            : this(Deployment, Reference, SetProperties, null) 
        {
        } 
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public StoreOperationSetDeploymentMetadata(IDefinitionAppId Deployment, StoreApplicationReference Reference, StoreOperationMetadataProperty[] SetProperties, StoreOperationMetadataProperty[] TestProperties) 
        {
            Size = (UInt32)Marshal.SizeOf(typeof(StoreOperationSetDeploymentMetadata));
            Flags = OpFlags.Nothing;
            this.Deployment = Deployment; 

            if (SetProperties != null) 
            { 
                PropertiesToSet = MarshalProperties(SetProperties);
                cPropertiesToSet = new IntPtr(SetProperties.Length); 
            }
            else
            {
                PropertiesToSet = IntPtr.Zero; 
                cPropertiesToSet = IntPtr.Zero;
            } 
 
            if (TestProperties != null)
            { 
                PropertiesToTest = MarshalProperties(TestProperties);
                cPropertiesToTest = new IntPtr(TestProperties.Length);
            }
            else 
            {
                PropertiesToTest = IntPtr.Zero; 
                cPropertiesToTest = IntPtr.Zero; 
            }
 
            InstallerReference = Reference.ToIntPtr();
        }

        [System.Security.SecurityCritical]  // auto-generated 
        public void Destroy()
        { 
            if (PropertiesToSet != IntPtr.Zero) 
            {
                DestroyProperties(PropertiesToSet, (ulong)cPropertiesToSet.ToInt64()); 
                PropertiesToSet = IntPtr.Zero;
                cPropertiesToSet = IntPtr.Zero;
            }
 
            if (PropertiesToTest != IntPtr.Zero)
            { 
                DestroyProperties(PropertiesToTest, (ulong)cPropertiesToTest.ToInt64()); 
                PropertiesToTest = IntPtr.Zero;
                cPropertiesToTest = IntPtr.Zero; 
            }

            if (InstallerReference != IntPtr.Zero)
            { 
                StoreApplicationReference.Destroy(InstallerReference);
                InstallerReference = IntPtr.Zero; 
            } 
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        private static void DestroyProperties(IntPtr rgItems, ulong iItems)
        {
            if (rgItems != IntPtr.Zero) 
            {
                IntPtr cursor = rgItems; 
                ulong iSlotSize = (ulong)Marshal.SizeOf(typeof(StoreOperationMetadataProperty)); 

                for (ulong i = 0; i < iItems; i++) 
                {
                    Marshal.DestroyStructure(
                        new IntPtr((long)((i * iSlotSize) + (ulong)rgItems.ToInt64())),
                        typeof(StoreOperationMetadataProperty)); 
                }
 
                Marshal.FreeCoTaskMem(rgItems); 
            }
        } 

        [System.Security.SecurityCritical]  // auto-generated
        private static IntPtr MarshalProperties(StoreOperationMetadataProperty[] Props)
        { 
            if ((Props == null) || (Props.Length == 0))
                return IntPtr.Zero; 
 
            int iSlotSize = Marshal.SizeOf(typeof(StoreOperationMetadataProperty));
            IntPtr retval = Marshal.AllocCoTaskMem(iSlotSize * Props.Length); 

            for (int i = 0; i != Props.Length; i++)
            {
                Marshal.StructureToPtr( 
                    Props[i],
                    new IntPtr((i * iSlotSize) + retval.ToInt64()), 
                    false); 
            }
 
            return retval;
        }
    }
 
    [StructLayout(LayoutKind.Sequential)]
    internal struct StoreOperationSetCanonicalizationContext 
    { 
        [MarshalAs(UnmanagedType.U4)] public UInt32 Size;
        [MarshalAs(UnmanagedType.U4)] public OpFlags Flags; 
        [MarshalAs(UnmanagedType.LPWStr)] public string BaseAddressFilePath;
        [MarshalAs(UnmanagedType.LPWStr)] public string ExportsFilePath;

        [Flags] 
        public enum OpFlags
        { 
            Nothing = 0 
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        public StoreOperationSetCanonicalizationContext(string Bases, string Exports)
        {
            Size = (UInt32)Marshal.SizeOf(typeof(StoreOperationSetCanonicalizationContext)); 
            Flags = OpFlags.Nothing;
            this.BaseAddressFilePath = Bases; 
            this.ExportsFilePath = Exports; 
        }
 
        public void Destroy()
        {
        }
    } 

    [StructLayout(LayoutKind.Sequential)] 
    internal struct StoreOperationScavenge 
    {
        [MarshalAs(UnmanagedType.U4)] public UInt32 Size; 
        [MarshalAs(UnmanagedType.U4)] public OpFlags Flags;
        [MarshalAs(UnmanagedType.U8)] public UInt64 SizeReclaimationLimit;
        [MarshalAs(UnmanagedType.U8)] public UInt64 RuntimeLimit;
        [MarshalAs(UnmanagedType.U4)] public UInt32 ComponentCountLimit; 

        [Flags] 
        public enum OpFlags 
        {
            Nothing = 0, 
            Light = 1,
            LimitSize = 2,
            LimitTime = 4,
            LimitCount = 8 
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated 
        public StoreOperationScavenge(bool Light, ulong SizeLimit, ulong RunLimit, uint ComponentLimit)
        { 
            Size = (UInt32)Marshal.SizeOf(typeof(StoreOperationScavenge));
            Flags = OpFlags.Nothing;

            if (Light) 
                Flags |= OpFlags.Light;
 
            this.SizeReclaimationLimit = SizeLimit; 
            if (SizeLimit != 0)
                this.Flags |= OpFlags.LimitSize; 

            this.RuntimeLimit = RunLimit;
            if (RunLimit != 0)
                this.Flags |= OpFlags.LimitTime; 

            this.ComponentCountLimit = ComponentLimit; 
            if (ComponentLimit != 0) 
                this.Flags |= OpFlags.LimitCount;
        } 

        public StoreOperationScavenge(bool Light) : this(Light, 0, 0, 0)
        {
        } 

        public void Destroy() 
        { 
        }
    } 

    internal enum StoreTransactionOperationType
    {
        Invalid = 0, 
        SetCanonicalizationContext = 14,
        StageComponent = 20, 
        PinDeployment = 21, 
        UnpinDeployment = 22,
        StageComponentFile = 23, 
        InstallDeployment = 24,
        UninstallDeployment = 25,
        SetDeploymentMetadata = 26,
        Scavenge = 27 
    }
 
 
    //
    // The transaction operation contains an operation key and 
    // a structure that contains the actual data.
    //
    [StructLayout(LayoutKind.Sequential)]
    internal struct StoreTransactionOperation 
    {
        [MarshalAs(UnmanagedType.U4)] public StoreTransactionOperationType Operation; 
        public StoreTransactionData Data; 
    }
 
    //
    // An IntPtr to a CoTaskMemAlloc'd transaction structure
    //
    [StructLayout(LayoutKind.Sequential)] 
    internal struct StoreTransactionData
    { 
        public IntPtr DataPtr; 
    }
 
    internal class Store
    {
        private IStore _pStore = null;
 
        public IStore InternalStore { get { return _pStore; } }
 
        public Store(IStore pStore) 
        {
            if (pStore == null) 
                throw new ArgumentNullException("pStore");

            this._pStore = pStore;
        } 

        [SecuritySafeCritical] 
        public uint[] Transact(StoreTransactionOperation[] operations) 
        {
            if ((operations == null) || (operations.Length == 0)) 
                throw new ArgumentException("operations");

            uint[] rgDispositions = new uint[operations.Length];
            int[] rgResults = new int[operations.Length]; 

            _pStore.Transact(new IntPtr(operations.Length), operations, rgDispositions, rgResults); 
 
            return rgDispositions;
        } 

#if !ISOLATION_IN_MSCORLIB
        public void Transact(StoreTransactionOperation[] operations, uint[] rgDispositions, int[] rgResults)
        { 
            if ((operations == null) || (operations.Length == 0))
                throw new ArgumentException("operations"); 
 
            _pStore.Transact(new IntPtr(operations.Length), operations, rgDispositions, rgResults);
        } 
#endif // !ISOLATION_IN_MSCORLIB

        [SecuritySafeCritical]
        public IDefinitionIdentity BindReferenceToAssemblyIdentity( 
            UInt32 Flags,
            IReferenceIdentity ReferenceIdentity, 
            uint cDeploymentsToIgnore, 
            IDefinitionIdentity[] DefinitionIdentity_DeploymentsToIgnore
            ) 
        {
            object o;
            System.Guid g = IsolationInterop.IID_IDefinitionIdentity;
            o=_pStore.BindReferenceToAssembly( 
                Flags,
                ReferenceIdentity, 
                cDeploymentsToIgnore, 
                DefinitionIdentity_DeploymentsToIgnore,
                ref g); 
            return (IDefinitionIdentity)o;
        }

        [SecuritySafeCritical] 
        public void CalculateDelimiterOfDeploymentsBasedOnQuota(
            UInt32 dwFlags, 
            UInt32 cDeployments, 
            IDefinitionAppId[] rgpIDefinitionAppId_Deployments,
            ref StoreApplicationReference InstallerReference, 
            UInt64 ulonglongQuota,
            ref UInt32 Delimiter,
            ref UInt64 SizeSharedWithExternalDeployment,
            ref UInt64 SizeConsumedByInputDeploymentArray 
            )
        { 
            IntPtr DelimIntPtr = IntPtr.Zero; 

            _pStore.CalculateDelimiterOfDeploymentsBasedOnQuota( 
                dwFlags,
                new IntPtr((Int64)cDeployments),
                rgpIDefinitionAppId_Deployments,
                ref InstallerReference, 
                ulonglongQuota,
                ref DelimIntPtr, 
                ref SizeSharedWithExternalDeployment, 
                ref SizeConsumedByInputDeploymentArray);
 
            Delimiter = (UInt32)DelimIntPtr.ToInt64();

            return;
        } 

        [SecuritySafeCritical] 
        public CMS.ICMS BindReferenceToAssemblyManifest( 
            UInt32 Flags,
            IReferenceIdentity ReferenceIdentity, 
            uint cDeploymentsToIgnore,
            IDefinitionIdentity[] DefinitionIdentity_DeploymentsToIgnore
            )
        { 
            object o;
            System.Guid g = IsolationInterop.IID_ICMS; 
            o=_pStore.BindReferenceToAssembly( 
                Flags,
                ReferenceIdentity, 
                cDeploymentsToIgnore,
                DefinitionIdentity_DeploymentsToIgnore,
                ref g);
            return (CMS.ICMS)o; 
        }
 
        [SecuritySafeCritical] 
        public CMS.ICMS GetAssemblyManifest(
            UInt32 Flags, 
            IDefinitionIdentity DefinitionIdentity
            )
        {
            object o; 
            System.Guid g = IsolationInterop.IID_ICMS;
            o=_pStore.GetAssemblyInformation( 
                Flags, 
                DefinitionIdentity,
                ref g); 
            return (CMS.ICMS)o;
        }

        /* 
            What's the point of this?  We already know the identity, we're passing it
            in on the commandline. 
         */ 
        [SecuritySafeCritical]
        public IDefinitionIdentity GetAssemblyIdentity( 
            UInt32 Flags,
            IDefinitionIdentity DefinitionIdentity
            )
        { 
            object o;
            System.Guid g = IsolationInterop.IID_IDefinitionIdentity; 
            o=_pStore.GetAssemblyInformation( 
                Flags,
                DefinitionIdentity, 
                ref g);
            return (IDefinitionIdentity)o;
        }
 
        [Flags]
        public enum EnumAssembliesFlags 
        { 
            Nothing = 0,
            VisibleOnly = 0x1, 
            MatchServicing = 0x2,
            ForceLibrarySemantics = 0x4
        }
 
        public StoreAssemblyEnumeration EnumAssemblies(EnumAssembliesFlags Flags)
        { 
            return this.EnumAssemblies(Flags, null); 
        }
 
        [SecuritySafeCritical]
        public StoreAssemblyEnumeration EnumAssemblies(EnumAssembliesFlags Flags, IReferenceIdentity refToMatch)
        {
            System.Guid g = IsolationInterop.GetGuidOfType(typeof(IEnumSTORE_ASSEMBLY)); 
            object o;
 
            o=_pStore.EnumAssemblies((UInt32)Flags, refToMatch, ref g); 
            return new StoreAssemblyEnumeration((IEnumSTORE_ASSEMBLY)o);
        } 

        [Flags]
        public enum EnumAssemblyFilesFlags
        { 
            Nothing = 0,
            IncludeInstalled = 0x1, 
            IncludeMissing = 0x2 
        }
 
        [SecuritySafeCritical]
        public StoreAssemblyFileEnumeration EnumFiles(EnumAssemblyFilesFlags Flags, IDefinitionIdentity Assembly)
        {
            System.Guid g = IsolationInterop.GetGuidOfType(typeof(IEnumSTORE_ASSEMBLY_FILE)); 
            object o;
            o=_pStore.EnumFiles((UInt32)Flags, Assembly, ref g); 
            return new StoreAssemblyFileEnumeration((IEnumSTORE_ASSEMBLY_FILE)o); 
        }
 
        [Flags]
        public enum EnumApplicationPrivateFiles
        {
            Nothing = 0, 
            IncludeInstalled = 0x1,
            IncludeMissing = 0x2 
        } 

        [SecuritySafeCritical] 
        public StoreAssemblyFileEnumeration EnumPrivateFiles(
                EnumApplicationPrivateFiles Flags,
                IDefinitionAppId Application,
                IDefinitionIdentity Assembly) 
        {
            System.Guid g = IsolationInterop.GetGuidOfType(typeof(IEnumSTORE_ASSEMBLY_FILE)); 
            object o; 
            o=_pStore.EnumPrivateFiles((UInt32)Flags, Application, Assembly, ref g);
            return new StoreAssemblyFileEnumeration((IEnumSTORE_ASSEMBLY_FILE)o); 
        }

        [Flags]
        public enum EnumAssemblyInstallReferenceFlags 
        {
            Nothing = 0 
        } 

        [SecuritySafeCritical] 
        public IEnumSTORE_ASSEMBLY_INSTALLATION_REFERENCE EnumInstallationReferences(
                EnumAssemblyInstallReferenceFlags Flags,
                IDefinitionIdentity Assembly
                ) 
        {
            System.Guid g = IsolationInterop.GetGuidOfType(typeof(IEnumSTORE_ASSEMBLY_INSTALLATION_REFERENCE)); 
            object o; 
            o=_pStore.EnumInstallationReferences((UInt32)Flags, Assembly, ref g);
            return (IEnumSTORE_ASSEMBLY_INSTALLATION_REFERENCE)o; 
        }

        public interface IPathLock : IDisposable
        { 
            string Path { get ; }
        } 
 
        private class AssemblyPathLock : IPathLock
        { 
            private IStore _pSourceStore = null;
            private IntPtr _pLockCookie = IntPtr.Zero;
            private string _path;
 
            public AssemblyPathLock(IStore s, IntPtr c, string path)
            { 
                _pSourceStore = s; 
                _pLockCookie = c;
                _path = path; 
            }

            [SecuritySafeCritical]
            private void Dispose(bool fDisposing) 
            {
                if (fDisposing) 
                    System.GC.SuppressFinalize(this); 

                if (_pLockCookie != IntPtr.Zero) 
                {
                    _pSourceStore.ReleaseAssemblyPath(_pLockCookie);
                    _pLockCookie = IntPtr.Zero;
                } 
            }
 
            ~AssemblyPathLock() { Dispose(false); } 
            void IDisposable.Dispose() { Dispose(true); }
 
            public string Path
            {
                get
                { 
                    return _path;
                } 
            } 
        }
 
        [SecuritySafeCritical]
        public IPathLock LockAssemblyPath(IDefinitionIdentity asm)
        {
            string thePath; 
            IntPtr theCookie;
            thePath=_pStore.LockAssemblyPath(0, asm, out theCookie); 
            return new AssemblyPathLock(_pStore, theCookie, thePath); 
        }
 
        private class ApplicationPathLock : IPathLock
        {
            private IStore _pSourceStore = null;
            private IntPtr _pLockCookie = IntPtr.Zero; 
            private string _path;
 
            public ApplicationPathLock(IStore s, IntPtr c, string path) 
            {
                _pSourceStore = s; 
                _pLockCookie = c;
                _path = path;
            }
 
            [SecuritySafeCritical]
            private void Dispose(bool fDisposing) 
            { 
                if (fDisposing)
                    System.GC.SuppressFinalize(this); 

                if (_pLockCookie != IntPtr.Zero)
                {
                    _pSourceStore.ReleaseApplicationPath(_pLockCookie); 
                    _pLockCookie = IntPtr.Zero;
                } 
            } 

            ~ApplicationPathLock() { Dispose(false); } 
            void IDisposable.Dispose() { Dispose(true); }

            public string Path
            { 
                get
                { 
                    return _path; 
                }
            } 
        }

        [SecuritySafeCritical]
        public IPathLock LockApplicationPath(IDefinitionAppId app) 
        {
            string thePath; 
            IntPtr theCookie; 
            thePath = _pStore.LockApplicationPath(0, app, out theCookie);
            return new ApplicationPathLock(_pStore, theCookie, thePath); 
        }

        [SecuritySafeCritical]
        public UInt64 QueryChangeID(IDefinitionIdentity asm) 
        {
            UInt64 ChangeId; 
            ChangeId=_pStore.QueryChangeID(asm); 
            return ChangeId;
        } 

        [Flags]
        public enum EnumCategoriesFlags
        { 
            Nothing = 0
        } 
 
        [SecuritySafeCritical]
        public StoreCategoryEnumeration EnumCategories(EnumCategoriesFlags Flags, IReferenceIdentity CategoryMatch) 
        {
            System.Guid g = IsolationInterop.GetGuidOfType(typeof(IEnumSTORE_CATEGORY));
            object o;
            o=_pStore.EnumCategories((UInt32)Flags, CategoryMatch, ref g); 
            return new StoreCategoryEnumeration((IEnumSTORE_CATEGORY)o);
        } 
 
        [Flags]
        public enum EnumSubcategoriesFlags 
        {
            Nothing = 0
        }
 
        public StoreSubcategoryEnumeration EnumSubcategories(EnumSubcategoriesFlags Flags, IDefinitionIdentity CategoryMatch)
        { 
            return this.EnumSubcategories(Flags, CategoryMatch, null); 
        }
 
        [SecuritySafeCritical]
        public StoreSubcategoryEnumeration  EnumSubcategories(EnumSubcategoriesFlags Flags, IDefinitionIdentity Category, string SearchPattern)
        {
            System.Guid g = IsolationInterop.GetGuidOfType(typeof(IEnumSTORE_CATEGORY_SUBCATEGORY)); 
            object o;
            o=_pStore.EnumSubcategories((UInt32)Flags, Category, SearchPattern, ref g); 
            return new StoreSubcategoryEnumeration((IEnumSTORE_CATEGORY_SUBCATEGORY)o); 
        }
 
        [Flags]
        public enum EnumCategoryInstancesFlags
        {
            Nothing = 0 
        }
 
        [SecuritySafeCritical] 
        public StoreCategoryInstanceEnumeration EnumCategoryInstances(EnumCategoryInstancesFlags Flags, IDefinitionIdentity Category, string SubCat)
        { 
            System.Guid g = IsolationInterop.GetGuidOfType(typeof(IEnumSTORE_CATEGORY_INSTANCE));
            object o;
            o=_pStore.EnumCategoryInstances((UInt32)Flags, Category, SubCat, ref g);
            return new StoreCategoryInstanceEnumeration((IEnumSTORE_CATEGORY_INSTANCE)o); 
        }
 
        [Flags] 
        public enum GetPackagePropertyFlags
        { 
            Nothing = 0
        }

        [System.Security.SecurityCritical]  // auto-generated 
        public byte[] GetDeploymentProperty(
                GetPackagePropertyFlags Flags, 
                IDefinitionAppId Deployment, 
                StoreApplicationReference Reference,
                Guid PropertySet, 
                string PropertyName
                )
        {
            BLOB b = new BLOB(); 
            byte[] retval = null;
 
            try 
            {
                _pStore.GetDeploymentProperty( 
                    (UInt32)Flags,
                    Deployment,
                    ref Reference,
                    ref PropertySet, 
                    PropertyName,
                    out b); 
 
                retval = new byte[b.Size];
                Marshal.Copy(b.BlobData, retval, 0, (int)b.Size); 
            }
            finally
            {
                b.Dispose(); 
            }
 
            return retval; 
        }
 
        [SecuritySafeCritical]
        public StoreDeploymentMetadataEnumeration EnumInstallerDeployments(
            Guid InstallerId,
            string InstallerName, 
            string InstallerMetadata,
            IReferenceAppId DeploymentFilter 
            ) 
        {
            object o = null; 
            StoreApplicationReference AppReference = new StoreApplicationReference(InstallerId, InstallerName, InstallerMetadata);

            o = _pStore.EnumInstallerDeploymentMetadata(
                0, 
                ref AppReference,
                DeploymentFilter, 
                ref IsolationInterop.IID_IEnumSTORE_DEPLOYMENT_METADATA); 

            return new StoreDeploymentMetadataEnumeration((IEnumSTORE_DEPLOYMENT_METADATA)o); 
        }

        [SecuritySafeCritical]
        public StoreDeploymentMetadataPropertyEnumeration EnumInstallerDeploymentProperties( 
            Guid InstallerId,
            string InstallerName, 
            string InstallerMetadata, 
            IDefinitionAppId Deployment
            ) 
        {
            object o = null;
            StoreApplicationReference AppReference = new StoreApplicationReference(InstallerId, InstallerName, InstallerMetadata);
 
            o = _pStore.EnumInstallerDeploymentMetadataProperties(
                0, 
                ref AppReference, 
                Deployment,
                ref IsolationInterop.IID_IEnumSTORE_DEPLOYMENT_METADATA_PROPERTY); 

            return new StoreDeploymentMetadataPropertyEnumeration((IEnumSTORE_DEPLOYMENT_METADATA_PROPERTY)o);
        }
 
    }
 
    [StructLayout(LayoutKind.Sequential)] 
    struct IStore_BindingResult_BoundVersion
    { 
        [MarshalAs(UnmanagedType.U2)] public UInt16 Revision;
        [MarshalAs(UnmanagedType.U2)] public UInt16 Build;
        [MarshalAs(UnmanagedType.U2)] public UInt16 Minor;
        [MarshalAs(UnmanagedType.U2)] public UInt16 Major; 
    }
 
    [StructLayout(LayoutKind.Sequential)] 
    struct IStore_BindingResult
    { 
        [MarshalAs(UnmanagedType.U4)] public UInt32 Flags;
        [MarshalAs(UnmanagedType.U4)] public UInt32 Disposition;
        public IStore_BindingResult_BoundVersion Component;
        public Guid CacheCoherencyGuid; 
        [MarshalAs(UnmanagedType.SysInt)] public IntPtr Reserved;
    } 
 
    [ComImport]
    [Guid("a5c62f6d-5e3e-4cd9-b345-6b281d7a1d1e")] 
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    internal interface IStore
    {
        [SecurityCritical] 
        void Transact([In] IntPtr /*SIZE_T*/ cOperation,
            [In, MarshalAs(UnmanagedType.LPArray)] StoreTransactionOperation[] rgOperations, 
            [Out, MarshalAs(UnmanagedType.LPArray)] uint[] rgDispositions, 
            [Out, MarshalAs(UnmanagedType.LPArray)] int[] /*HRESULT*/ rgResults
            ); 

        [SecurityCritical]
        [return :MarshalAs(UnmanagedType.IUnknown)]
        object BindReferenceToAssembly( 
            [In] UInt32 Flags,
            [In] IReferenceIdentity ReferenceIdentity, 
            [In] uint cDeploymentsToIgnore, 
            [In, MarshalAs(UnmanagedType.LPArray)] IDefinitionIdentity[] DefinitionIdentity_DeploymentsToIgnore,
            [In] ref Guid riid 
            );

        [SecurityCritical]
        void CalculateDelimiterOfDeploymentsBasedOnQuota( 
            [In] UInt32 dwFlags,
            [In] IntPtr /*SIZE_T*/ cDeployments, 
            [In, MarshalAs(UnmanagedType.LPArray)] IDefinitionAppId[] rgpIDefinitionAppId_Deployments, 
            [In] ref StoreApplicationReference InstallerReference,
            [In] UInt64 ulonglongQuota, 
            [Out, In] ref IntPtr /*SIZE_T*/ Delimiter,
            [Out, In] ref UInt64 SizeSharedWithExternalDeployment,
            [Out, In] ref UInt64 SizeConsumedByInputDeploymentArray
            ); 

        [SecurityCritical] 
        IntPtr BindDefinitions( 
            [In] UInt32 Flags,
            [In, MarshalAs(UnmanagedType.SysInt)] IntPtr Count, 
            [In, MarshalAs(UnmanagedType.LPArray)] IDefinitionIdentity [] DefsToBind,
            [In] UInt32 DeploymentsToIgnore,
            [In, MarshalAs(UnmanagedType.LPArray)] IDefinitionIdentity [] DefsToIgnore
            ); 

        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.IUnknown)] 
        object GetAssemblyInformation(
            [In] UInt32 Flags, 
            [In] IDefinitionIdentity DefinitionIdentity,
            [In] ref Guid riid
            );
 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.IUnknown)] 
        object EnumAssemblies( 
            [In] UInt32 Flags,
            [In] IReferenceIdentity ReferenceIdentity_ToMatch, 
            [In] ref Guid riid
            );

        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.IUnknown)]
        object EnumFiles( 
            [In] UInt32 Flags, 
            [In] IDefinitionIdentity DefinitionIdentity,
            [In] ref Guid riid 
            );

        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.IUnknown)] 
        object EnumInstallationReferences(
            [In] UInt32 Flags, 
            [In] IDefinitionIdentity DefinitionIdentity, 
            [In] ref Guid riid
            ); 

        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.LPWStr)]
        string LockAssemblyPath( 
            [In] UInt32 Flags,
            [In] IDefinitionIdentity DefinitionIdentity, 
            [Out] out IntPtr Cookie 
            );
 
        [SecurityCritical]
        void ReleaseAssemblyPath(
            [In] IntPtr Cookie
            ); 

        [SecurityCritical] 
        UInt64 QueryChangeID( 
            [In] IDefinitionIdentity DefinitionIdentity
            ); 

        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.IUnknown)]
        object EnumCategories( 
            [In] UInt32 Flags,
            [In] IReferenceIdentity ReferenceIdentity_ToMatch, 
            [In] ref Guid riid 
            );
 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.IUnknown)]
        object EnumSubcategories(
            [In] UInt32 Flags, 
            [In] IDefinitionIdentity CategoryId,
            [In, MarshalAs(UnmanagedType.LPWStr)] string SubcategoryPathPattern, 
            [In] ref Guid riid 
            );
 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.IUnknown)]
        object EnumCategoryInstances(
            [In] UInt32 Flags, 
            [In] IDefinitionIdentity CategoryId,
            [In, MarshalAs(UnmanagedType.LPWStr)] string SubcategoryPath, 
            [In] ref Guid riid 
            );
 
        // ISSUE - AMD64: Had to change to this because somehow returning BLOB
        // in the following crashes on amd64. Need to resolve the issue.
        [SecurityCritical]
        void GetDeploymentProperty( 
            [In] UInt32 Flags,
            [In] IDefinitionAppId DeploymentInPackage, 
            [In] ref StoreApplicationReference Reference, 
            [In] ref Guid PropertySet,
            [In, MarshalAs(UnmanagedType.LPWStr)] string pcwszPropertyName, 
            out BLOB blob
            );

        [SecurityCritical] 
        [return:MarshalAs(UnmanagedType.LPWStr)]
        string LockApplicationPath( 
            [In] UInt32 Flags, 
            [In] IDefinitionAppId ApId,
            [Out] out IntPtr Cookie 
            );

        [SecurityCritical]
        void ReleaseApplicationPath( 
            [In] IntPtr Cookie
            ); 
 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.IUnknown)] 
        object EnumPrivateFiles(
            [In] UInt32 Flags,
            [In] IDefinitionAppId Application,
            [In] IDefinitionIdentity DefinitionIdentity, 
            [In] ref Guid riid
            ); 
 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.IUnknown)] 
        object EnumInstallerDeploymentMetadata(
            [In] UInt32 Flags,
            [In] ref StoreApplicationReference Reference,
            [In] IReferenceAppId Filter, 
            [In] ref Guid riid
            ); 
 
        [SecurityCritical]
        [return:MarshalAs(UnmanagedType.IUnknown)] 
        object EnumInstallerDeploymentMetadataProperties(
            [In] UInt32 Flags,
            [In] ref StoreApplicationReference Reference,
            [In] IDefinitionAppId Filter, 
            [In] ref Guid riid
            ); 
 
    }
 
    internal class StoreTransaction : IDisposable
    {
        private System.Collections.ArrayList _list = new System.Collections.ArrayList();
        private StoreTransactionOperation[] _storeOps = null; 

        public void Add(StoreOperationInstallDeployment o) { _list.Add(o); } 
        public void Add(StoreOperationPinDeployment o) { _list.Add(o); } 
        public void Add(StoreOperationSetCanonicalizationContext o) { _list.Add(o); }
        public void Add(StoreOperationSetDeploymentMetadata o) { _list.Add(o); } 
        public void Add(StoreOperationStageComponent o) { _list.Add(o); }
        public void Add(StoreOperationStageComponentFile o) { _list.Add(o); }
        public void Add(StoreOperationUninstallDeployment o) { _list.Add(o); }
        public void Add(StoreOperationUnpinDeployment o) { _list.Add(o); } 
        public void Add(StoreOperationScavenge o) { _list.Add(o); }
 
        ~StoreTransaction() 
        {
            Dispose(false); 
        }

        void IDisposable.Dispose()
        { 
            Dispose(true);
        } 
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        private void Dispose(bool fDisposing) 
        {
            if (fDisposing)
            {
                System.GC.SuppressFinalize(this); 
            }
 
            StoreTransactionOperation[] opList = _storeOps; 
            _storeOps = null;
 
            //
            // If we had already created the operation list, then destroy the corresponding
            // objects that we'd copied out to the unmanaged GC data
            // 
            if (opList != null)
            { 
                for (int i = 0; i != opList.Length; i++) 
                {
                    StoreTransactionOperation op = opList[i]; 
                    if (op.Data.DataPtr != IntPtr.Zero)
                    {
                        //
                        // Destroy the structure as appropriate 
                        //
                        switch (op.Operation) 
                        { 
                        case StoreTransactionOperationType.StageComponent:
                            Marshal.DestroyStructure(op.Data.DataPtr, typeof(StoreOperationStageComponent)); 
                            break;
                        case StoreTransactionOperationType.StageComponentFile:
                            Marshal.DestroyStructure(op.Data.DataPtr, typeof(StoreOperationStageComponentFile));
                            break; 
                        case StoreTransactionOperationType.PinDeployment:
                            Marshal.DestroyStructure(op.Data.DataPtr, typeof(StoreOperationPinDeployment)); 
                            break; 
                        case StoreTransactionOperationType.UninstallDeployment:
                            Marshal.DestroyStructure(op.Data.DataPtr, typeof(StoreOperationUninstallDeployment)); 
                            break;
                        case StoreTransactionOperationType.UnpinDeployment:
                            Marshal.DestroyStructure(op.Data.DataPtr, typeof(StoreOperationUnpinDeployment));
                            break; 
                        case StoreTransactionOperationType.InstallDeployment:
                            Marshal.DestroyStructure(op.Data.DataPtr, typeof(StoreOperationInstallDeployment)); 
                            break; 
                        case StoreTransactionOperationType.SetCanonicalizationContext:
                            Marshal.DestroyStructure(op.Data.DataPtr, typeof(StoreOperationSetCanonicalizationContext)); 
                            break;
                        case StoreTransactionOperationType.SetDeploymentMetadata:
                            Marshal.DestroyStructure(op.Data.DataPtr, typeof(StoreOperationSetDeploymentMetadata));
                            break; 
                        case StoreTransactionOperationType.Scavenge:
                            Marshal.DestroyStructure(op.Data.DataPtr, typeof(StoreOperationScavenge)); 
                            break; 
                        }
 
                        //
                        // Free the pointer
                        //
                        Marshal.FreeCoTaskMem(op.Data.DataPtr); 
                    }
                } 
            } 

        } 

        public StoreTransactionOperation[] Operations
        {
            get 
            {
                if (_storeOps == null) 
                    _storeOps = GenerateStoreOpsList(); 
                return _storeOps;
            } 
        }

        //
        // For each transaction that was lobbed in here, go and allocate/blit the transaction into 
        // an unmanaged object.
        // 
        [System.Security.SecuritySafeCritical]  // auto-generated 
        private StoreTransactionOperation[] GenerateStoreOpsList()
        { 
            StoreTransactionOperation[] txnList = new StoreTransactionOperation[_list.Count];

            for (int i = 0; i != _list.Count; i++)
            { 
                object o = _list[i];
                System.Type t = o.GetType(); 
 
                txnList[i].Data.DataPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(o));
                Marshal.StructureToPtr(o, txnList[i].Data.DataPtr, false); 


                if (t == typeof(StoreOperationSetCanonicalizationContext))
                { 
                    txnList[i].Operation = StoreTransactionOperationType.SetCanonicalizationContext;
                } 
                else if (t == typeof(StoreOperationStageComponent)) 
                {
                    txnList[i].Operation = StoreTransactionOperationType.StageComponent; 
                }
                else if (t == typeof(StoreOperationPinDeployment))
                {
                    txnList[i].Operation = StoreTransactionOperationType.PinDeployment; 
                }
                else if (t == typeof(StoreOperationUnpinDeployment)) 
                { 
                    txnList[i].Operation = StoreTransactionOperationType.UnpinDeployment;
                } 
                else if (t == typeof(StoreOperationStageComponentFile))
                {
                    txnList[i].Operation = StoreTransactionOperationType.StageComponentFile;
                } 
                else if (t == typeof(StoreOperationInstallDeployment))
                { 
                    txnList[i].Operation = StoreTransactionOperationType.InstallDeployment; 
                }
                else if (t == typeof(StoreOperationUninstallDeployment)) 
                {
                    txnList[i].Operation = StoreTransactionOperationType.UninstallDeployment;
                }
                else if (t == typeof(StoreOperationSetDeploymentMetadata)) 
                {
                    txnList[i].Operation = StoreTransactionOperationType.SetDeploymentMetadata; 
                } 
                else if (t == typeof(StoreOperationScavenge))
                { 
                    txnList[i].Operation = StoreTransactionOperationType.Scavenge;
                }
                else
                { 
                    throw new Exception("How did you get here?");
                } 
            } 

            return txnList; 
        }
    }

    [ComImport] 
    [Guid("ace1b703-1aac-4956-ab87-90cac8b93ce6")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    interface IManifestParseErrorCallback 
    {
        [SecurityCritical] 
        void OnError(
            [In] UInt32 StartLine,
            [In] UInt32 nStartColumn,
            [In] UInt32 cCharacterCount, 
            [In] Int32 hr,
            [In, MarshalAs(UnmanagedType.LPWStr)] string ErrorStatusHostFile, 
            [In] UInt32 ParameterCount, 
            [In, MarshalAs(UnmanagedType.LPArray)] string[] Parameters);
    }; 



 
    //
    // Global isolation interop state. 
    // 
    internal static class IsolationInterop
    { 
        private static object _synchObject = new object();
#if !ISOLATION_IN_MSCORLIB
        private static Store _userStore = null;
        private static Store _systemStore = null; 
#endif // !ISOLATION_IN_MSCORLIB
        private static IIdentityAuthority _idAuth = null; 
        private static IAppIdAuthority _appIdAuth = null; 

#if ISOLATION_IN_MSCORLIB || ISOLATION_IN_CLICKONCE 


#if FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME
        public const String IsolationDllName = "coreclr.dll"; 
#else //FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME
        public const String IsolationDllName = "clr.dll"; 
#endif //FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME 

 
#elif ISOLATION_IN_ISOWIN32
        public const String IsolationDllName = "isowin32.dll";
#elif ISOLATION_DLLNAME_IS_ISOWIN32
        public const String IsolationDllName = "isowin32.dll"; 
#elif ISOLATION_DLLNAME_IS_ISOMAN
        public const String IsolationDllName = "isoman.dll"; 
#elif ISOLATION_DLLNAME_IS_ISOLATION 
        public const String IsolationDllName = "isolation.dll";
#elif ISOLATION_DLLNAME_IS_NTDLL 
        public const String IsolationDllName = "ntdll.dll";
#else
        public const String IsolationDllName = "sxs.dll";
#endif 

#if !ISOLATION_IN_MSCORLIB 
        public static Store UserStore 
        {
            get 
            {
                if (_userStore == null)
                {
                    lock (_synchObject) 
                    {
                        if (_userStore == null) 
                            _userStore = new Store(GetUserStore(0, IntPtr.Zero, ref IID_IStore) as IStore); 
                    }
                } 

                return _userStore;
            }
        } 
#endif // !ISOLATION_IN_MSCORLIB
 
        // Create a new user store object. 
        // Call into GetUserStore to get a new IStore handle.
        [SecuritySafeCritical] 
        public static Store GetUserStore()
        {
            return new Store(GetUserStore(0, IntPtr.Zero, ref IID_IStore) as IStore);
        } 

#if !ISOLATION_IN_MSCORLIB 
        public static Store SystemStore 
        {
            get 
            {
                if (_systemStore == null)
                {
                    lock (_synchObject) 
                    {
                        if (_systemStore == null) 
                            _systemStore = new Store(GetSystemStore(0, ref IID_IStore) as IStore); 
                    }
                } 

                return _systemStore;
            }
        } 
#endif // !ISOLATION_IN_MSCORLIB
 
        public static IIdentityAuthority IdentityAuthority 
        {
            [SecuritySafeCritical] 
            get
            {
                if (_idAuth == null)
                { 
                    lock (_synchObject)
                    { 
                        if (_idAuth == null) 
                            _idAuth = GetIdentityAuthority();
                    } 
                }

                return _idAuth;
            } 
        }
 
        public static IAppIdAuthority AppIdAuthority 
        {
            [System.Security.SecuritySafeCritical] 
            get
            {
                if (_appIdAuth == null)
                { 
                    lock (_synchObject)
                    { 
                        if (_appIdAuth == null) 
                            _appIdAuth = GetAppIdAuthority();
                    } 
                }
                return _appIdAuth;
            }
        } 

        [StructLayout(LayoutKind.Sequential)] 
        internal struct CreateActContextParameters 
        {
            [MarshalAs(UnmanagedType.U4)] public UInt32 Size; 
            [MarshalAs(UnmanagedType.U4)] public UInt32 Flags;
            [MarshalAs(UnmanagedType.SysInt)] public IntPtr CustomStoreList;
            [MarshalAs(UnmanagedType.SysInt)] public IntPtr CultureFallbackList;
            [MarshalAs(UnmanagedType.SysInt)] public IntPtr ProcessorArchitectureList; 
            [MarshalAs(UnmanagedType.SysInt)] public IntPtr Source;
            [MarshalAs(UnmanagedType.U2)] public UInt16 ProcArch; 
 
            [Flags]
            public enum CreateFlags 
            {
                Nothing = 0,
                StoreListValid = 1,
                CultureListValid = 2, 
                ProcessorFallbackListValid = 4,
                ProcessorValid = 8, 
                SourceValid = 16, 
                IgnoreVisibility = 32
            } 
        }

        [StructLayout(LayoutKind.Sequential)]
        internal struct CreateActContextParametersSource 
        {
            [MarshalAs(UnmanagedType.U4)] public UInt32 Size; 
            [MarshalAs(UnmanagedType.U4)] public UInt32 Flags; 
            [MarshalAs(UnmanagedType.U4)] public UInt32 SourceType;
            [MarshalAs(UnmanagedType.SysInt)] public IntPtr Data; 

            [Flags]
            public enum SourceFlags
            { 
                Definition = 1,
                Reference = 2 
            } 

 
            [System.Security.SecurityCritical]  // auto-generated
            public IntPtr ToIntPtr()
            {
                IntPtr p = Marshal.AllocCoTaskMem(Marshal.SizeOf(this)); 
                Marshal.StructureToPtr(this, p, false);
                return p; 
            } 

            [System.Security.SecurityCritical]  // auto-generated 
            public static void Destroy(IntPtr p)
            {
                Marshal.DestroyStructure(p, typeof(CreateActContextParametersSource));
                Marshal.FreeCoTaskMem(p); 
            }
        } 
 
        #if !ISOLATION_IN_MSCORLIB
        [StructLayout(LayoutKind.Sequential)] 
        internal struct CreateActContextParametersSourceReferenceAppid
        {
            [MarshalAs(UnmanagedType.U4)] public UInt32 Size;
            [MarshalAs(UnmanagedType.U4)] public UInt32 Flags; 
            public IReferenceAppId AppId;
 
            public IntPtr ToIntPtr() 
            {
                IntPtr p = Marshal.AllocCoTaskMem(Marshal.SizeOf(this)); 
                Marshal.StructureToPtr(this, p, false);
                return p;
            }
 
            public static void Destroy(IntPtr p)
            { 
                Marshal.DestroyStructure(p, typeof(CreateActContextParametersSourceReferenceAppid)); 
                Marshal.FreeCoTaskMem(p);
            } 
        }
        #endif // !ISOLATION_IN_MSCORLIB

        [StructLayout(LayoutKind.Sequential)] 
        internal struct CreateActContextParametersSourceDefinitionAppid
        { 
            [MarshalAs(UnmanagedType.U4)] public UInt32 Size; 
            [MarshalAs(UnmanagedType.U4)] public UInt32 Flags;
            public IDefinitionAppId AppId; 

            [System.Security.SecurityCritical]  // auto-generated
            public IntPtr ToIntPtr()
            { 
                IntPtr p = Marshal.AllocCoTaskMem(Marshal.SizeOf(this));
                Marshal.StructureToPtr(this, p, false); 
                return p; 
            }
 
            [System.Security.SecurityCritical]  // auto-generated
            public static void Destroy(IntPtr p)
            {
                Marshal.DestroyStructure(p, typeof(CreateActContextParametersSourceDefinitionAppid)); 
                Marshal.FreeCoTaskMem(p);
            } 
        } 

        [System.Security.SecuritySafeCritical]  // auto-generated 
        internal static IActContext CreateActContext(IDefinitionAppId AppId)
        {
            CreateActContextParameters Parameters;
            CreateActContextParametersSource SourceInfo; 
            CreateActContextParametersSourceDefinitionAppid DefAppIdSource;
 
            Parameters.Size = (UInt32)Marshal.SizeOf(typeof(CreateActContextParameters)); 
            Parameters.Flags = (UInt32)CreateActContextParameters.CreateFlags.SourceValid;
            Parameters.CustomStoreList = IntPtr.Zero; 
            Parameters.CultureFallbackList = IntPtr.Zero;
            Parameters.ProcessorArchitectureList = IntPtr.Zero;
            Parameters.Source = IntPtr.Zero;
            Parameters.ProcArch = 0; 

            SourceInfo.Size = (UInt32)Marshal.SizeOf(typeof(CreateActContextParametersSource)); 
            SourceInfo.Flags = 0; 
            SourceInfo.SourceType = (UInt32)CreateActContextParametersSource.SourceFlags.Definition;
            SourceInfo.Data = IntPtr.Zero; 

            DefAppIdSource.Size = (UInt32)Marshal.SizeOf(typeof(CreateActContextParametersSourceDefinitionAppid));
            DefAppIdSource.Flags = 0;
            DefAppIdSource.AppId = AppId; 

            try 
            { 
                SourceInfo.Data = DefAppIdSource.ToIntPtr();
                Parameters.Source = SourceInfo.ToIntPtr(); 

                return CreateActContext(ref Parameters) as IActContext;
            }
            // 
            // Don't care about exceptions, but we don't want to leak nonmanaged heap
            // 
            finally 
            {
                if (SourceInfo.Data != IntPtr.Zero) 
                {
                    CreateActContextParametersSourceDefinitionAppid.Destroy(SourceInfo.Data);
                    SourceInfo.Data = IntPtr.Zero;
                } 

                if (Parameters.Source != IntPtr.Zero) 
                { 
                    CreateActContextParametersSource.Destroy(Parameters.Source);
                    Parameters.Source = IntPtr.Zero; 
                }
            }
        }
 
        #if !ISOLATION_IN_MSCORLIB
        internal static IActContext CreateActContext(IReferenceAppId AppId) 
        { 
            CreateActContextParameters Parameters;
            CreateActContextParametersSource SourceInfo; 
            CreateActContextParametersSourceReferenceAppid RefAppIdSource;

            Parameters.Size = (UInt32)Marshal.SizeOf(typeof(CreateActContextParameters));
            Parameters.Flags = (UInt32)CreateActContextParameters.CreateFlags.SourceValid; 
            Parameters.CustomStoreList = IntPtr.Zero;
            Parameters.CultureFallbackList = IntPtr.Zero; 
            Parameters.ProcessorArchitectureList = IntPtr.Zero; 
            Parameters.Source = IntPtr.Zero;
            Parameters.ProcArch = 0; 

            SourceInfo.Size = (UInt32)Marshal.SizeOf(typeof(CreateActContextParametersSource));
            SourceInfo.Flags = 0;
            SourceInfo.SourceType = (UInt32)CreateActContextParametersSource.SourceFlags.Reference; 
            SourceInfo.Data = IntPtr.Zero;
 
            RefAppIdSource.Size = (UInt32)Marshal.SizeOf(typeof(CreateActContextParametersSourceReferenceAppid)); 
            RefAppIdSource.Flags = 0;
            RefAppIdSource.AppId = AppId; 

            try
            {
                SourceInfo.Data = RefAppIdSource.ToIntPtr(); 
                Parameters.Source = SourceInfo.ToIntPtr();
 
                return CreateActContext(ref Parameters) as IActContext; 
            }
            // 
            // Don't care about exceptions, but we don't want to leak nonmanaged heap
            //
            finally
            { 
                if (SourceInfo.Data != IntPtr.Zero)
                { 
                    CreateActContextParametersSourceDefinitionAppid.Destroy(SourceInfo.Data); 
                    SourceInfo.Data = IntPtr.Zero;
                } 

                if (Parameters.Source != IntPtr.Zero)
                {
                    CreateActContextParametersSource.Destroy(Parameters.Source); 
                    Parameters.Source = IntPtr.Zero;
                } 
            } 
        }
        #endif // !ISOLATION_IN_MSCORLIB 

        [ResourceExposure(ResourceScope.None)]
        [DllImport(IsolationDllName, PreserveSig = false)]
        [return:MarshalAs(UnmanagedType.IUnknown)] 
        internal static extern object CreateActContext(ref CreateActContextParameters Params);
 
        // Guids. 
        public static Guid IID_ICMS = GetGuidOfType(typeof(CMS.ICMS));
 
        public static Guid IID_IDefinitionIdentity = GetGuidOfType(typeof(IDefinitionIdentity));
        public static Guid IID_IManifestInformation = GetGuidOfType(typeof(IManifestInformation));
        public static Guid IID_IEnumSTORE_ASSEMBLY = GetGuidOfType(typeof(IEnumSTORE_ASSEMBLY));
        public static Guid IID_IEnumSTORE_ASSEMBLY_FILE = GetGuidOfType(typeof(IEnumSTORE_ASSEMBLY_FILE)); 
        public static Guid IID_IEnumSTORE_CATEGORY = GetGuidOfType(typeof(IEnumSTORE_CATEGORY));
        public static Guid IID_IEnumSTORE_CATEGORY_INSTANCE = GetGuidOfType(typeof(IEnumSTORE_CATEGORY_INSTANCE)); 
        public static Guid IID_IEnumSTORE_DEPLOYMENT_METADATA = GetGuidOfType(typeof(IEnumSTORE_DEPLOYMENT_METADATA)); 
        public static Guid IID_IEnumSTORE_DEPLOYMENT_METADATA_PROPERTY = GetGuidOfType(typeof(IEnumSTORE_DEPLOYMENT_METADATA_PROPERTY));
        public static Guid IID_IStore = GetGuidOfType(typeof(IStore)); 

        public static Guid GUID_SXS_INSTALL_REFERENCE_SCHEME_OPAQUESTRING =
            new Guid("2ec93463-b0c3-45e1-8364-327e96aea856");
 
        public static Guid SXS_INSTALL_REFERENCE_SCHEME_SXS_STRONGNAME_SIGNED_PRIVATE_ASSEMBLY =
            new Guid("3ab20ac0-67e8-4512-8385-a487e35df3da"); 
 
        // ISSUE - Should change this to stdcall.
        [SecurityCritical] 
        [ResourceExposure(ResourceScope.None)]
        [DllImport(IsolationDllName, PreserveSig = false)]
        [return :MarshalAs(UnmanagedType.IUnknown)]
        internal static extern object CreateCMSFromXml( 
            [In] byte[] buffer,
            [In] UInt32 bufferSize, 
            [In] IManifestParseErrorCallback Callback, 
            [In] ref Guid riid);
 
        [SecurityCritical]
        [ResourceExposure(ResourceScope.Machine)]
        [DllImport(IsolationDllName, PreserveSig = false)]
        [return :MarshalAs(UnmanagedType.IUnknown)] 
        internal static extern object ParseManifest(
            [In, MarshalAs(UnmanagedType.LPWStr)] string pszManifestPath, 
            [In] IManifestParseErrorCallback pIManifestParseErrorCallback, 
            [In] ref Guid riid);//            string pszManifestPath, IManifestParseErrorCallback pIManifestParseErrorCallback, ref Guid riid);
 
        [SecurityCritical]
        [ResourceExposure(ResourceScope.None)]
        [DllImport(IsolationDllName, PreserveSig = false)]
        [return :MarshalAs(UnmanagedType.IUnknown)] 
        private static extern object GetUserStore([In] UInt32 Flags, [In] IntPtr hToken, [In] ref Guid riid);
 
#if !ISOLATION_IN_MSCORLIB 
        [SecurityCritical]
        [ResourceExposure(ResourceScope.None)] 
        [DllImport(IsolationDllName, PreserveSig = false)]
        [return :MarshalAs(UnmanagedType.IUnknown)]
        private static extern object GetSystemStore([In] UInt32 Flags, [In] ref Guid riid);
#endif // !ISOLATION_IN_MSCORLIB 

        [SecurityCritical] 
        [ResourceExposure(ResourceScope.None)] 
        [DllImport(IsolationDllName, PreserveSig = false)]
        [return :MarshalAs(UnmanagedType.Interface)] 
        private static extern IIdentityAuthority GetIdentityAuthority();

        [SecurityCritical]
        [ResourceExposure(ResourceScope.None)] 
        [DllImport(IsolationDllName, PreserveSig = false)]
        [return :MarshalAs(UnmanagedType.Interface)] 
        private static extern IAppIdAuthority GetAppIdAuthority(); 

#if !ISOLATION_IN_MSCORLIB 
        [ResourceExposure(ResourceScope.None)]
        [DllImport(IsolationDllName, PreserveSig = false)]
        [return :MarshalAs(UnmanagedType.IUnknown)]
        internal static extern object GetUserStateManager([In] UInt32 Flags, [In] IntPtr hToken, [In] ref Guid riid); 
#endif // !ISOLATION_IN_MSCORLIB
 
        internal static Guid GetGuidOfType(Type type) 
        {
            GuidAttribute guidAttr = (GuidAttribute)Attribute.GetCustomAttribute( 
                type, typeof(GuidAttribute), false);
            return new Guid(guidAttr.Value);
        }
    } 

#if !ISOLATION_IN_MSCORLIB 
    internal class ApplicationContext 
    {
        private IActContext _appcontext = null; 

        internal ApplicationContext(IActContext a)
        {
            if (a == null) 
                throw new ArgumentNullException();
            _appcontext = a; 
        } 

        public ApplicationContext(DefinitionAppId appid) 
        {
            if (appid == null)
                throw new ArgumentNullException();
            _appcontext = IsolationInterop.CreateActContext(appid._id); 
        }
 
        public ApplicationContext(ReferenceAppId appid) 
        {
            if (appid == null) 
                throw new ArgumentNullException();
            _appcontext = IsolationInterop.CreateActContext(appid._id);
        }
 
        public DefinitionAppId Identity
        { 
            get 
            {
                object o; 
                _appcontext.GetAppId(out o);
                return new DefinitionAppId(o as IDefinitionAppId);
            }
        } 

        public string BasePath 
        { 
            get
            { 
                string s;
                _appcontext.ApplicationBasePath(0, out s);
                return s;
            } 
        }
 
        public string ReplaceStrings(string culture, string toreplace) 
        {
            string replaced; 
            _appcontext.ReplaceStringMacros(0, culture, toreplace, out replaced);
            return replaced;
        }
 
        internal CMS.ICMS GetComponentManifest(DefinitionIdentity component)
        { 
            object o; 
            _appcontext.GetComponentManifest(0, component._id, ref IsolationInterop.IID_ICMS, out o);
            return o as CMS.ICMS; 
        }

        internal string GetComponentManifestPath(DefinitionIdentity component)
        { 
            object o;
            string s; 
            _appcontext.GetComponentManifest(0, component._id, ref IsolationInterop.IID_IManifestInformation, out o); 
            ((IManifestInformation)o).get_FullPath(out s);
            return s; 
        }

        public string GetComponentPath(DefinitionIdentity component)
        { 
            string retval;
            _appcontext.GetComponentPayloadPath(0, component._id, out retval); 
            return retval; 
        }
 
        public DefinitionIdentity MatchReference(ReferenceIdentity TheRef)
        {
            object o;
            _appcontext.FindReferenceInContext(0, TheRef._id, out o); 
            return new DefinitionIdentity(o as IDefinitionIdentity);
        } 
 
        public EnumDefinitionIdentity Components
        { 
            get
            {
                object o;
                _appcontext.EnumComponents(0, out o); 
                return new EnumDefinitionIdentity(o as IEnumDefinitionIdentity);
            } 
        } 

        public void PrepareForExecution() 
        {
            _appcontext.PrepareForExecution(IntPtr.Zero, IntPtr.Zero);
        }
 
        public enum ApplicationState
        { 
            Undefined = 0, 
            Starting = 1,
            Running = 2 
        }

        public enum ApplicationStateDisposition
        { 
            Undefined = 0,
            Starting = 1, 
            Starting_Migrated = (1 | (1 << 16)), 
            Running = 2,
            Running_FirstTime = (2 | (1 << 17)), 
        }

        public ApplicationStateDisposition SetApplicationState(ApplicationState s)
        { 
            UInt32 theDisposition;
            _appcontext.SetApplicationRunningState(0, (UInt32)s, out theDisposition); 
            return (ApplicationStateDisposition)theDisposition; 
        }
 
        public string StateLocation
        {
            get
            { 
                string s;
                _appcontext.GetApplicationStateFilesystemLocation(0, UIntPtr.Zero, IntPtr.Zero, out s); 
                return s; 
            }
        } 
    }
#endif // !ISOLATION_IN_MSCORLIB

    [ComImport] 
    [Guid("81c85208-fe61-4c15-b5bb-ff5ea66baad9")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
    internal interface IManifestInformation 
    {
        [SecurityCritical] 
        void get_FullPath(
            [Out, MarshalAs(UnmanagedType.LPWStr)] out string FullPath
            );
    } 

    [ComImport] 
    [Guid("0af57545-a72a-4fbe-813c-8554ed7d4528")] 
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    internal interface IActContext 
    {
        // Returns IDefinitionAppId
        [SecurityCritical]
        void GetAppId( 
            [Out, MarshalAs(UnmanagedType.Interface)] out object AppId
            ); 
 
        // Returns IEnumCATEGORY
        [SecurityCritical] 
        void EnumCategories(
            [In] UInt32 Flags,
            [In] IReferenceIdentity CategoryToMatch,
            [In] ref Guid riid, 
            [Out, MarshalAs(UnmanagedType.Interface)] out object EnumOut
            ); 
 
        // Returns IEnumCATEGORY_SUBCATEGORY
        [SecurityCritical] 
        void EnumSubcategories(
            [In] UInt32 Flags,
            [In] IDefinitionIdentity CategoryId,
            [In, MarshalAs(UnmanagedType.LPWStr)] string SubcategoryPattern, 
            [In] ref Guid riid,
            [Out, MarshalAs(UnmanagedType.Interface)] out object EnumOut 
            ); 

        // Returns IEnumCATEGORY_INSTANCE 
        [SecurityCritical]
        void EnumCategoryInstances(
            [In] UInt32 Flags,
            [In] IDefinitionIdentity CategoryId, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string Subcategory,
            [In] ref Guid riid, 
            [Out, MarshalAs(UnmanagedType.Interface)] out object EnumOut 
            );
 
        [SecurityCritical]
        void ReplaceStringMacros(
            [In] UInt32 Flags,
            [In, MarshalAs(UnmanagedType.LPWStr)] string Culture, 
            [In, MarshalAs(UnmanagedType.LPWStr)] string ReplacementPattern,
            [Out, MarshalAs(UnmanagedType.LPWStr)] out string Replaced 
            ); 

        [SecurityCritical] 
        void GetComponentStringTableStrings(
            [In] UInt32 Flags,
            [In, MarshalAs(UnmanagedType.SysUInt)] IntPtr ComponentIndex,
            [In, MarshalAs(UnmanagedType.SysUInt)] IntPtr StringCount, 
            [Out, MarshalAs(UnmanagedType.LPArray)] string[] SourceStrings,
            [Out, MarshalAs(UnmanagedType.LPArray)] out string[] DestinationStrings, 
            [In, MarshalAs(UnmanagedType.SysUInt)] IntPtr CultureFallbacks 
            );
 
        [SecurityCritical]
        void GetApplicationProperties(
            [In] UInt32 Flags,
            [In] UIntPtr cProperties, 
            [In, MarshalAs(UnmanagedType.LPArray)] string[] PropertyNames,
            [Out, MarshalAs(UnmanagedType.LPArray)] out string[] PropertyValues, 
            [Out, MarshalAs(UnmanagedType.LPArray)] out UIntPtr[] ComponentIndicies 
            );
 
        [SecurityCritical]
        void ApplicationBasePath(
            [In] UInt32 Flags,
            [Out, MarshalAs(UnmanagedType.LPWStr)] out string ApplicationPath 
            );
 
        // Returns either IDefinitionIdentity or ICMS 
        [SecurityCritical]
        void GetComponentManifest( 
            [In] UInt32 Flags,
            [In] IDefinitionIdentity ComponentId,
            [In] ref Guid riid,
            [Out, MarshalAs(UnmanagedType.Interface)] out object ManifestInteface 
            );
 
        [SecurityCritical] 
        void GetComponentPayloadPath(
            [In] UInt32 Flags, 
            [In] IDefinitionIdentity ComponentId,
            [Out, MarshalAs(UnmanagedType.LPWStr)] out string PayloadPath
            );
 
        // Returns an IDefinitionIdentity
        [SecurityCritical] 
        void FindReferenceInContext( 
            [In] UInt32 dwFlags,
            [In] IReferenceIdentity Reference, 
            [Out, MarshalAs(UnmanagedType.Interface)] out object MatchedDefinition
            );

        // Returns an IActContext 
        [SecurityCritical]
        void CreateActContextFromCategoryInstance( 
            [In] UInt32 dwFlags, 
            [In] ref CATEGORY_INSTANCE CategoryInstance,
            [Out, MarshalAs(UnmanagedType.Interface)] out object ppCreatedAppContext 
            );

        // Returns an IEnumDefinitionIdentity
        [SecurityCritical] 
        void EnumComponents(
            [In] UInt32 dwFlags, 
            [Out, MarshalAs(UnmanagedType.Interface)] out object ppIdentityEnum 
            );
 
        // Inputs is a pointer to an IAPP_CONTEXT_PREPARE_FOR_EXECUTION_INPUTS
        // structure, which for now should/can be NULL - pass IntPtr.Zero. Outputs
        // should point at an IAPP_CONTEXT_PREPARE_FOR_EXECUTION_OUTPUTS structure,
        // which should/can be likewise null for now. 
        [SecurityCritical]
        void PrepareForExecution( 
            [In, MarshalAs(UnmanagedType.SysInt)] IntPtr Inputs, 
            [In, MarshalAs(UnmanagedType.SysInt)] IntPtr Outputs
            ); 

        [SecurityCritical]
        void SetApplicationRunningState(
            [In] UInt32 dwFlags, 
            [In] UInt32 ulState,
            [Out] out UInt32 ulDisposition 
            ); 

        // For now, the coordinate list (should be a pointer to a STATE_COORDINATE_LIST 
        // should be null.
        [SecurityCritical]
        void GetApplicationStateFilesystemLocation(
            [In] UInt32 dwFlags, 
            [In] UIntPtr Component,
            [In, MarshalAs(UnmanagedType.SysInt)] IntPtr pCoordinateList, 
            [Out, MarshalAs(UnmanagedType.LPWStr)] out string ppszPath 
            );
 
        [SecurityCritical]
        void FindComponentsByDefinition(
            [In] UInt32 dwFlags,
            [In] UIntPtr ComponentCount, 
            [In, MarshalAs(UnmanagedType.LPArray)] IDefinitionIdentity[] Components,
            [Out, MarshalAs(UnmanagedType.LPArray)] UIntPtr[] Indicies, 
            [Out, MarshalAs(UnmanagedType.LPArray)] UInt32[] Dispositions 
            );
 
        [SecurityCritical]
        void FindComponentsByReference(
            [In] UInt32 dwFlags,
            [In] UIntPtr Components, 
            [In, MarshalAs(UnmanagedType.LPArray)] IReferenceIdentity[] References,
            [Out, MarshalAs(UnmanagedType.LPArray)] UIntPtr[] Indicies, 
            [Out, MarshalAs(UnmanagedType.LPArray)] UInt32[] Dispositions 
            );
    } 

    enum StateManager_RunningState
    {
        Undefined = 0, 
        Starting = 1,
        Running = 2 
    }; 

    [ComImport] 
    [Guid("07662534-750b-4ed5-9cfb-1c5bc5acfd07")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface IStateManager
    { 
        [SecurityCritical]
        void PrepareApplicationState( 
            [In] UIntPtr Inputs, 
            ref UIntPtr Outputs
            ); 

        [SecurityCritical]
        void SetApplicationRunningState(
            [In] UInt32 Flags, 
            [In] IActContext Context,
            [In] UInt32 RunningState, 
            [Out] out UInt32 Disposition 
            );
 
        [SecurityCritical]
        void GetApplicationStateFilesystemLocation(
            [In] UInt32 Flags,
            [In] IDefinitionAppId Appidentity, 
            [In] IDefinitionIdentity ComponentIdentity,
            [In] UIntPtr Coordinates, 
            [Out, MarshalAs(UnmanagedType.LPWStr)] out string Path 
            );
 
        [SecurityCritical]
        void Scavenge(
            [In] UInt32 Flags,
            [Out] out UInt32 Disposition 
            );
    }; 
#endif 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK