ArcEngine二次开发：ArcGIS for Desktop/Engine 10.2 cannot connect to previous versions of the ArcGis Licen

using System;
using System.Windows.Forms;
using ESRI.ArcGIS.esriSystem;

namespace MapExcelNpoi01
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);

            IAoInitialize aoInitialize = new AoInitialize();
            esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
            licenseStatus = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new MainForm());
        }
    }
}

小例子代码

using System;
using System.Windows;
using System.Collections.Generic;
using ESRI.ArcGIS;
using ESRI.ArcGIS.esriSystem;
using System.Windows.Forms;

namespace ZCFZB
{
    internal class LicenseInitializer
    {
       
        /// <summary>
        /// 在 ArcGIS 运行时未建立绑定时触发事件
        /// </summary>
        public event EventHandler ResolveBindingEvent;

        #region Private members

        private const string MessageNoRuntimeBinding = "Invalid ArcGIS runtime binding.";
        private const string MessageNoAoInitialize = "ArcObjects initialization failed.";
        private const string MessageNoLicensesRequested = "Product: No licenses were requested";
        private const string MessageProductAvailable = "Product: {0}: Available";
        private const string MessageProductNotLicensed = "Product: {0}: Not Licensed";
        private const string MessageExtensionAvailable = " Extension: {0}: Available";
        private const string MessageExtensionNotLicensed = " Extension: {0}: Not Licensed";
        private const string MessageExtensionFailed = " Extension: {0}: Failed";
        private const string MessageExtensionUnavailable = " Extension: {0}: Unavailable";

        private IAoInitialize m_AoInit = null;
        private bool m_hasShutDown = false;
        private bool m_hasInitializeProduct = false;

        private List<int> m_requestedProducts;
        private List<esriLicenseExtensionCode> m_requestedExtensions;
        private Dictionary<esriLicenseProductCode, esriLicenseStatus> m_productStatus = new Dictionary<esriLicenseProductCode, esriLicenseStatus>();
        private Dictionary<esriLicenseExtensionCode, esriLicenseStatus> m_extensionStatus = new Dictionary<esriLicenseExtensionCode, esriLicenseStatus>();

        // 从低到高检查产品授权信息
        private bool m_productCheckOrdering = true;

        #endregion

        public LicenseInitializer()
        {
            ResolveBindingEvent += new EventHandler(BindingArcGISRuntime);
        }

        void BindingArcGISRuntime(object sender, EventArgs e)
        {
            //
            // ArcGIS运行时逐个绑定,在此可以设定绑定Desktop或者Engine运行时
            //
            ProductCode[] supportedRuntimes = new ProductCode[] { ProductCode.Desktop };
            foreach (ProductCode c in supportedRuntimes)
            {
                if (RuntimeManager.Bind(c))
                    return;
            }

            //
            // ArcGIS运行时均绑定失败,程序强制退出
            //

            MessageBox.Show("ArcGIS运行时绑定失败!请安装ArcGIS软件产品后才可正常运行软件。");
            System.Environment.Exit(0);
        }


        /// <summary>
        /// 给指定软件产品初始化扩展模块功能权限
        /// </summary>    
        /// <returns>ArcGIS扩展模块权限初始化成功</returns>
        /// <remarks>
        /// 在ArcGIS扩展模块权限初始化前必须确保ArcGIS运行时成功绑定,如Desktop或者Engine运行时
        /// </remarks>
        public bool InitializeApplication(esriLicenseProductCode[] productCodes, esriLicenseExtensionCode[] extensionLics)
        {
            // 添加软件产品扩展模块
            m_requestedProducts = new List<int>();
            foreach (esriLicenseProductCode code in productCodes)
            {
                int requestCodeNum = Convert.ToInt32(code);
                if (!m_requestedProducts.Contains(requestCodeNum))
                {
                    m_requestedProducts.Add(requestCodeNum);
                }
            }
            AddExtensions(extensionLics);

            // 在调用ArcObject任何功能前期,请确保ArcGIS运行时成功绑定
            if (RuntimeManager.ActiveRuntime == null)
            {
                EventHandler temp = ResolveBindingEvent;
                if (temp != null)
                {
                    temp(this, new EventArgs());
                }
            }

            return Initialize();
        }

        /// <summary>
        /// ArcGIS产品和扩展模块授权状态信息
        /// </summary>
        public string LicenseMessage()
        {
            if (RuntimeManager.ActiveRuntime == null)
            {
                return MessageNoRuntimeBinding;
            }

            if (m_AoInit == null)
            {
                return MessageNoAoInitialize;
            }

            string prodStatus = string.Empty;
            string extStatus = string.Empty;
            if (m_productStatus == null || m_productStatus.Count == 0)
            {
                prodStatus = MessageNoLicensesRequested + Environment.NewLine;
            }
            else if (m_productStatus.ContainsValue(esriLicenseStatus.esriLicenseAlreadyInitialized)
                || m_productStatus.ContainsValue(esriLicenseStatus.esriLicenseCheckedOut))
            {
                prodStatus = ReportInformation(m_AoInit as ILicenseInformation,
                    m_AoInit.InitializedProduct(),
                    esriLicenseStatus.esriLicenseCheckedOut) + Environment.NewLine;
            }
            else
            {
                // 当ArcGIS产品及扩展模块授权失败时获取信息
                foreach (KeyValuePair<esriLicenseProductCode, esriLicenseStatus> item in m_productStatus)
                {
                    prodStatus += ReportInformation(m_AoInit as ILicenseInformation,
                        item.Key, item.Value) + Environment.NewLine;
                }
            }

            foreach (KeyValuePair<esriLicenseExtensionCode, esriLicenseStatus> item in m_extensionStatus)
            {
                string info = ReportInformation(m_AoInit as ILicenseInformation, item.Key, item.Value);
                if (!string.IsNullOrEmpty(info))
                    extStatus += info + Environment.NewLine;
            }

            return (prodStatus + extStatus).Trim();
        }

        /// <summary>
        /// 关闭 AoInitialize 对象并检入扩展，以确保以正确的顺序卸载所有已使用的 ESRI 库。
        /// </summary>
        /// <remarks>一旦该关闭被调用,将不能重新初始化产品授权和不能调用使用任何ArcObjects对象。</remarks>
        public void ShutdownApplication()
        {
            if (m_hasShutDown)
                return;

            // 检入扩展授权
            if (m_AoInit != null)
            {
                foreach (KeyValuePair<esriLicenseExtensionCode, esriLicenseStatus> item in m_extensionStatus)
                {
                    if (item.Value == esriLicenseStatus.esriLicenseCheckedOut)
                        m_AoInit.CheckInExtension(item.Key);
                }
                m_AoInit.Shutdown();
            }

            m_requestedProducts = null;
            m_requestedExtensions = null;
            m_extensionStatus = null;
            m_productStatus = null;

            m_hasShutDown = true;
        }

        /// <summary>
        /// 指示扩展当前是否签出。
        /// </summary>
        public bool IsExtensionCheckedOut(esriLicenseExtensionCode code)
        {
            return m_AoInit != null && m_AoInit.IsExtensionCheckedOut(code);
        }

        /// <summary>
        /// 设置要签出的 ArcObjects 代码的扩展名。
        /// </summary>
        public bool AddExtensions(params esriLicenseExtensionCode[] requestCodes)
        {
            if (m_requestedExtensions == null)
                m_requestedExtensions = new List<esriLicenseExtensionCode>();
            foreach (esriLicenseExtensionCode code in requestCodes)
            {
                if (!m_requestedExtensions.Contains(code))
                    m_requestedExtensions.Add(code);
            }

            if (m_hasInitializeProduct)
                return CheckOutLicenses(this.InitializedProduct);

            return false;
        }

        /// <summary>
        /// 当不再需要扩展名时，请签入扩展名。
        /// </summary>
        public void RemoveExtensions(params esriLicenseExtensionCode[] requestCodes)
        {
            if (m_extensionStatus == null || m_extensionStatus.Count == 0)
                return;

            foreach (esriLicenseExtensionCode code in requestCodes)
            {
                if (m_extensionStatus.ContainsKey(code))
                {
                    if (m_AoInit.CheckInExtension(code) == esriLicenseStatus.esriLicenseCheckedIn)
                    {
                        m_extensionStatus[code] = esriLicenseStatus.esriLicenseCheckedIn;
                    }
                }
            }
        }

        /// <summary>
        /// 获取/设置产品代码检查的顺序。如果为真，检查从最低到最高的许可证。默认为真。
        /// </summary>
        public bool InitializeLowerProductFirst
        {
            get
            {
                return m_productCheckOrdering;
            }
            set
            {
                m_productCheckOrdering = value;
            }
        }

        /// <summary>
        /// 检索在 ArcObjects 应用程序中初始化的产品代码。
        /// </summary>
        public esriLicenseProductCode InitializedProduct
        {
            get
            {
                if (m_AoInit != null)
                {
                    try
                    {
                        return m_AoInit.InitializedProduct();
                    }
                    catch
                    {
                        return 0;
                    }
                }
                return 0;
            }
        }

        #region Helper methods

        private bool Initialize()
        {
            if (RuntimeManager.ActiveRuntime == null)
                return false;

            if (m_requestedProducts == null || m_requestedProducts.Count == 0)
                return false;

            bool productInitialized = false;

            m_requestedProducts.Sort();
            // 从高到低申请许可证
            if (!InitializeLowerProductFirst)
                m_requestedProducts.Reverse();

            m_AoInit = new AoInitializeClass();
            esriLicenseProductCode currentProduct = new esriLicenseProductCode();
            foreach (int prodNumber in m_requestedProducts)
            {
                esriLicenseProductCode prod = (esriLicenseProductCode)Enum.ToObject(typeof(esriLicenseProductCode), prodNumber);
                esriLicenseStatus status = m_AoInit.IsProductCodeAvailable(prod);
                if (status == esriLicenseStatus.esriLicenseAvailable)
                {
                    status = m_AoInit.Initialize(prod);
                    if (status == esriLicenseStatus.esriLicenseAlreadyInitialized ||
                        status == esriLicenseStatus.esriLicenseCheckedOut)
                    {
                        productInitialized = true;
                        currentProduct = m_AoInit.InitializedProduct();
                    }
                }

                m_productStatus.Add(prod, status);

                if (productInitialized)
                    break;
            }

            m_hasInitializeProduct = productInitialized;
            m_requestedProducts.Clear();

            // 在尝试所有请求的许可证之后，没有初始化任何产品，退出。
            if (!productInitialized)
            {
                return false;
            }

            // 检查扩展模块授权信息
            return CheckOutLicenses(currentProduct);
        }

        private bool CheckOutLicenses(esriLicenseProductCode currentProduct)
        {
            bool allSuccessful = true;
            // 申请扩展模块授权信息
            if (m_requestedExtensions != null && currentProduct != 0)
            {
                foreach (esriLicenseExtensionCode ext in m_requestedExtensions)
                {
                    esriLicenseStatus licenseStatus = m_AoInit.IsExtensionCodeAvailable(currentProduct, ext);
                    // 跳过不可用扩展模块
                    if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
                    {
                        licenseStatus = m_AoInit.CheckOutExtension(ext);
                    }
                    allSuccessful = (allSuccessful && licenseStatus == esriLicenseStatus.esriLicenseCheckedOut);
                    if (m_extensionStatus.ContainsKey(ext))
                        m_extensionStatus[ext] = licenseStatus;
                    else
                        m_extensionStatus.Add(ext, licenseStatus);
                }

                m_requestedExtensions.Clear();
            }

            return allSuccessful;
        }


        private string ReportInformation(ILicenseInformation licInfo,
        esriLicenseProductCode code, esriLicenseStatus status)
        {
            string prodName = string.Empty;
            try
            {
                prodName = licInfo.GetLicenseProductName(code);
            }
            catch
            {
                prodName = code.ToString();
            }

            string statusInfo = string.Empty;

            switch (status)
            {
                case esriLicenseStatus.esriLicenseAlreadyInitialized:
                case esriLicenseStatus.esriLicenseCheckedOut:
                    statusInfo = string.Format(MessageProductAvailable, prodName);
                    break;
                default:
                    statusInfo = string.Format(MessageProductNotLicensed, prodName);
                    break;
            }

            return statusInfo;
        }
        private string ReportInformation(ILicenseInformation licInfo,
            esriLicenseExtensionCode code, esriLicenseStatus status)
        {
            string extensionName = string.Empty;
            try
            {
                extensionName = licInfo.GetLicenseExtensionName(code);
            }
            catch
            {
                extensionName = code.ToString();
            }

            string statusInfo = string.Empty;

            switch (status)
            {
                case esriLicenseStatus.esriLicenseAlreadyInitialized:
                case esriLicenseStatus.esriLicenseCheckedOut:
                    statusInfo = string.Format(MessageExtensionAvailable, extensionName);
                    break;
                case esriLicenseStatus.esriLicenseCheckedIn:
                    break;
                case esriLicenseStatus.esriLicenseUnavailable:
                    statusInfo = string.Format(MessageExtensionUnavailable, extensionName);
                    break;
                case esriLicenseStatus.esriLicenseFailure:
                    statusInfo = string.Format(MessageExtensionFailed, extensionName);
                    break;
                default:
                    statusInfo = string.Format(MessageExtensionNotLicensed, extensionName);
                    break;
            }

            return statusInfo;
        }
        #endregion Helper methods
    }
}

  private static ZCFZB.LicenseInitializer m_AOLicenseInitializer = new ZCFZB.LicenseInitializer();
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
{
 if (!m_AOLicenseInitializer.InitializeApplication(
                    new esriLicenseProductCode[] { esriLicenseProductCode.esriLicenseProductCodeAdvanced },
                    new esriLicenseExtensionCode[] { 
                        esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodeSchematics, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodeArcScan, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodeBusiness, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodeMLE, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodeCOGO, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodeGeoStats, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodePublisher, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodeDataInteroperability, 
                        esriLicenseExtensionCode.esriLicenseExtensionCodeTracking }))
                {
                    MessageBox.Show("未检测到ESRI产品安装或者ESRI产品未成功授权!", "提示");
                    return;
                }

}

ARCENGINE 程序运行时在IAOINITIALIZE M_AOINITIALIZE = NEW AOINITIALIZECLASS();处报错--解决办法

报错信息：检索 COM 类工厂中 CLSID 为 {E01BE902-CC85-4B13-A828-02E789E0DDA9} 的组件失败，原因是出现以下错误: 80040154 没有注册类 

解决办法：在项目--属性--生成里，把目标平台改成x86

原因：ArcObjects COM组件不能被64位的.net程序加载

正尝试在 OS 加载程序锁内执行托管代码。不要尝试在 DllMain 或映像初始化函数内运行托管代码，这样做会导致