Outlook 2003 View Control con C #

Question

Voglio incorporare un personalizzato c modulo # Windows (o WPF) controllo utente in una visione prospettiva. Sto usando Outlook 2003 e Visual Studio 2008.

ho fatto scaricare un esempio per Outlook 2007 qui:

http://blogs.msdn.com/e2eblog/archive/2008/01/09/outlook-folder-homepage-hosting-wpf-activex-and-windows-forms-controls.aspx

e anche qui:

http://msdn.microsoft.com/en-us/library /aa479345.aspx

L'ho provato e sotto 2007 si sta lavorando, ma per il 2003 sto ottenendo il seguente errore quando voglio aprire la vista:

Impossibile completare l'operazione a causa di errore 80131509

posso avviarlo da Visual Studio, si registra la cartella bene, il debug di opere e tutto il resto. Si crea una pagina HTML che contiene il mio tipo come parametro di oggetto -. Ma il metodo di inizializzazione che deve essere chiamato è o non è presente (non mostrato tramite JS) o ha alcuni errori

I punti di interruzione per RegisterSafeForScripting sono mai colpito -. Forse legata a quella

Answer 1

In primo luogo vi ringrazio AMissico - e io esaminerà la descrizione e link che hai fornito pure. Il codice follwinng ha fatto per me il trucco (ma i controlli dei pulsanti e gli altri hanno rotto il layout - ma PAM funziona così userò WPF). Devo refactoring del codice, ma era la versione di lavoro per me ...

L'esempio ho finalmente trovato che ha funzionato dopo tweaking un po 'per me: http://www.microsoft. com / downloads / Details.aspx? FamilyID = 078124E9-1E88-4F51-8C98-3C1999CFE743 & displaylang = it

Il seguente file è più o meno preso dall'esempio precedente

using System;
using System.IO;
using System.Collections.Generic;
using MSOutlook = Microsoft.Office.Interop.Outlook;
using System.Runtime.InteropServices;

namespace Outlook2003KnowledgeBaseAddIn.Setup
{
    public sealed class FolderHomePage
    {
        /// <summary>
        /// List of web view files that have been written out during this Outlook intance
        /// </summary>
        private static List<string> listWebViewFiles = new List<string>();

        /// <summary>
        /// Registers a specific managed type as a folder home page. Returns a file path for the folder home page
        /// </summary>
        /// <param name="viewType">Type of the home page control. 
        /// Control must be ComVisible should be registered safe for scripting</param>
        /// <returns>file path to the folder home page</returns>
        public static string RegisterType(Type viewType)
        {
            if (viewType == null)
                return null;

            //TODO: ensure that viewType inherits from System.Windows.Forms.Control

            //Create the Local App Data directory for the Web view files to reside in
            string webViewDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), Properties.Resources.WebViewDirectoryName);
            if (Directory.Exists(webViewDirectory) == false)
                Directory.CreateDirectory(webViewDirectory);

            //Create the web view file name based on the viewType guid in the web view directory
            string webViewFile = Path.Combine(webViewDirectory, viewType.GUID.ToString("N") + ".htm");

            //if the file has been written out already in this session, return
            if (listWebViewFiles.Contains(webViewFile))
                return webViewFile;

            //If the file exists, delete it (for versioning reasons)
            if (File.Exists(webViewFile))
                File.Delete(webViewFile);

            //Open a file stream and text writer for the Web view stream
            FileStream stm = new FileStream(webViewFile, FileMode.Create, FileAccess.Write);
            TextWriter writer = new StreamWriter(stm, System.Text.Encoding.ASCII);

            //Look to see if the viewType has an init method that takes a single Outlook App parameter
            System.Reflection.MethodInfo initInfo = viewType.GetMethod("Initialize", new Type[] { typeof(MSOutlook.Application) });

            //If the viewType doesn't have an Init method, just write out the html page header
            //TODO move HTML code to resource strings
            if (initInfo == null)
            {
                writer.WriteLine("<html><body rightmargin = '0' leftmargin ='0' topmargin ='0' bottommargin = '0'>");
            }
            //If the viewType does have an Init method, write script to trap the Body.OnLoad event and call the Init method
            //passing in the window.external.OutlookApplication object as the parameter
            else
            {
                writer.WriteLine("<html><body rightmargin = '0' leftmargin ='0' topmargin ='0' bottommargin = '0' onload='OnBodyLoad()'>");
                writer.WriteLine("<script>\n\tfunction OnBodyLoad()\n\t{\n\t\tvar oApp = window.external.OutlookApplication;");
                writer.WriteLine("\t\t{0}.Initialize(oApp);", viewType.Name);
                writer.WriteLine("\t}\n</script>");
            }

            //Write out an object tag that loads up the viewType as a com object via its class id
            writer.WriteLine("<object classid='clsid:{0}' ID='{1}' VIEWASTEXT width='100%' height='100%'/>", viewType.GUID, viewType.Name);
            writer.WriteLine("</body></html>");

            //Close the file
            writer.Close();
            stm.Close();

            //save this file name so we don't write it out multiple times per outlook session
            listWebViewFiles.Add(webViewFile);

            return webViewFile;
        }

        private const string CATID_SafeForScripting = "7DD95801-9882-11CF-9FA9-00AA006C42C4";
        private const string CATID_SafeForInitializing = "7DD95802-9882-11CF-9FA9-00AA006C42C4";

        /// <summary>
        /// Registers a managed type that's exposed for COM interop as safe for initializing and scripting
        /// </summary>
        /// <param name="comType"></param>
        public static void RegisterSafeForScripting(Type comType)
        {
            Guid clsid = comType.GUID;
            Guid interfaceSafeScripting = new Guid(CATID_SafeForScripting);
            Guid interfaceSafeForInitializing = new Guid(CATID_SafeForInitializing);

            ICatRegister reg = (ICatRegister)new ComComponentCategoriesManager();
            reg.RegisterClassImplCategories(ref clsid, 1, new Guid[] { interfaceSafeScripting });
            reg.RegisterClassImplCategories(ref clsid, 1, new Guid[] { interfaceSafeForInitializing });
        }

        /// <summary>
        /// Unregisters a managed type that's exposed for COM interop as safe for initializing and scripting
        /// </summary>
        /// <param name="comType"></param>
        public static void UnregisterSafeForScripting(Type comType)
        {
            Guid clsid = comType.GUID;
            Guid interfaceSafeScripting = new Guid(CATID_SafeForScripting);
            Guid interfaceSafeForInitializing = new Guid(CATID_SafeForInitializing);

            ICatRegister reg = (ICatRegister)new ComComponentCategoriesManager();
            reg.UnRegisterClassImplCategories(ref clsid, 1, new Guid[] { interfaceSafeScripting });
            reg.UnRegisterClassImplCategories(ref clsid, 1, new Guid[] { interfaceSafeForInitializing });
        }

    }


    [ComImport(), Guid("0002E005-0000-0000-C000-000000000046")]
    class ComComponentCategoriesManager
    {
    }

    [ComImport(), Guid("0002E012-0000-0000-C000-000000000046")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface ICatRegister
    {
        void RegisterCategories(int cCategories, IntPtr rgCategoryInfo);

        void UnRegisterCategories(int cCategories, IntPtr rgcatid);

        void RegisterClassImplCategories(
                [In()] ref Guid rclsid,
                int cCategories,
                [In(), MarshalAs(UnmanagedType.LPArray)] Guid[] rgcatid);

        void UnRegisterClassImplCategories(
                [In()] ref Guid rclsid,
                int cCategories,
                [In(), MarshalAs(UnmanagedType.LPArray)] Guid[] rgcatid);

        void RegisterClassReqCategories(
            [In()] ref Guid rclsid,
            int cCategories,
            [In(), MarshalAs(UnmanagedType.LPArray)] Guid[] rgcatid);

        void UnRegisterClassReqCategories(
            [In()] ref Guid rclsid,
            int cCategories,
            [In(), MarshalAs(UnmanagedType.LPArray)] Guid[] rgcatid);
    }

}

insieme a questo file:

using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Policy;
using System.Security;
using Outlook2003KnowledgeBaseAddIn.Setup;
using Outlook2003KnowledgeBaseAddIn.UI;
using Outlook2003KnowledgeBaseAddIn.UI.OutlookIntegration;

namespace Outlook2003KnowledgeBaseAddIn
{
    [System.ComponentModel.RunInstaller(true)]
    public class Installer : System.Configuration.Install.Installer
    {
        public Installer()
        {
        }

        public override void Install(System.Collections.IDictionary stateSaver)
        {
            base.Install(stateSaver);

            try
            {
                ConfigureSecurityPolicy();
                RegisterFolderHomePages();
            }
            catch (Exception ex)
            {
                throw new System.Configuration.Install.InstallException("Custom Installer Failed", ex);
            }
        }

        public override void Uninstall(System.Collections.IDictionary savedState)
        {
            base.Uninstall(savedState);

            try
            {
                DeleteSecurityPolicy();
                UnregisterFolderHomePages();
            }
            catch (Exception ex)
            {
                throw new System.Configuration.Install.InstallException("Custom Installer Failed", ex);
            }
        }

        private void RegisterFolderHomePages()
        {
            //Utility.FolderHomePage.RegisterSafeForScripting(typeof(FolderHomePages.AccountToday));
            FolderHomePage.RegisterSafeForScripting(typeof(WebViewControl));
        }

        private void UnregisterFolderHomePages()
        {
            //Utility.FolderHomePage.UnregisterSafeForScripting(typeof(FolderHomePages.AccountToday));
            FolderHomePage.UnregisterSafeForScripting(typeof(WebViewControl));
        }

        private void ConfigureSecurityPolicy()
        {
            // Find the machine policy level
            PolicyLevel machinePolicyLevel = GetMachinePolicyLevel();

            // Get the install directory of the current installer
            string assemblyPath = this.Context.Parameters["assemblypath"];
            string installDirectory =
                assemblyPath.Substring(0, assemblyPath.LastIndexOf("\\"));

            if (!installDirectory.EndsWith(@"\"))
                installDirectory += @"\";

            installDirectory += "*";

            // Create the code group
            CodeGroup codeGroup = new UnionCodeGroup(
                new UrlMembershipCondition(installDirectory),
                new PolicyStatement(new NamedPermissionSet("FullTrust")));
            codeGroup.Description = Properties.Resources.CasPolicyDescription;
            codeGroup.Name = Properties.Resources.CasPolicyName;

            // Add the code group
            machinePolicyLevel.RootCodeGroup.AddChild(codeGroup);

            // Save changes
            SecurityManager.SavePolicy();
        }

        private static void DeleteSecurityPolicy()
        {
            PolicyLevel machinePolicy = GetMachinePolicyLevel();

            foreach (CodeGroup codeGroup in machinePolicy.RootCodeGroup.Children)
            {
                if (codeGroup.Name == Properties.Resources.CasPolicyName)
                    machinePolicy.RootCodeGroup.RemoveChild(codeGroup);
            }

            SecurityManager.SavePolicy();
        }

        private static PolicyLevel GetMachinePolicyLevel()
        {
            System.Collections.IEnumerator policyHierarchy = SecurityManager.PolicyHierarchy();

            while (policyHierarchy.MoveNext())
            {
                PolicyLevel level = (PolicyLevel)policyHierarchy.Current;
                if (level.Type == PolicyLevelType.Machine)
                    return level;
            }

            throw new ApplicationException("Could not find Machine Policy level. Code Access Security is not configured for this application.");
        }
    }
}

Questo metodo imposta la visualizzazione Web:

private void CreateWebViewFolders()
{
    MSOutlook.MAPIFolder root = Folder.GetRootFolder(Application.Session);

    MSOutlook.MAPIFolder webViewFolder = Folder.CreateFolder(root, Properties.Resources.WebViewFolderName);
    webViewFolder.WebViewURL = FolderHomePage.RegisterType(typeof(WebViewControl));
    webViewFolder.WebViewOn = true;
}

Answer 2

Sembra che è necessario creare una politica di sicurezza Runtime per l'assemblaggio. Visual Studio / VSTO impostato automaticamente. È possibile controllare questo eseguendo il progetto da Visual Studio quindi aprire l'applicazione di configurazione di Microsoft .NET Framework 2.0 in Strumenti di amministrazione. Individuare Criteri di protezione runtime e controllare i Gruppi di codice. progetti VSTO sono sotto Utente> codice Gruppi> All_Code> VSTOProjects.

In seguito sono le mie note.

codice di accesso la politica di sicurezza (caspol) Classi

• Creata dalla distribuzione di soluzioni ufficio utilizzando Windows Installer versione 3.
• Rinominato classe SetSecurity a CaspolSecurityPolicyInstaller.

strumento di politica Code Access Security (Caspol.exe)

Lo strumento Criterio Code Access Security consente agli utenti e agli amministratori di modificare la politica di sicurezza per il livello di politica di macchina, il livello di criterio utente, e il livello di politica delle imprese.

Distribuzione

La distribuzione di Visual Studio 2005 Tools per le soluzioni Office System SE Utilizzo di Windows Installer (parte 1 di 2)

• Articolo: http://msdn.microsoft.com/en-us /library/bb332051.aspx
• Download: http://go.microsoft.com/fwlink/?LinkId=83721
  • Visual Studio 2005 Tools per Office Second Edition Esempio: Soluzioni di distribuzione di Office utilizzando Windows Installer versione 3 (OfficeVSTO2005SEWindowsInstallerV3.msi)