ArcGIS10.2.2 获取产品许可报错。 RuntimeManager.Bind 返回False 解决

RuntimeManager.Bind() 需要 应用程序为 32位。 需要把应用程序改为 32 位的应用程序

附上手动获取许可方法

    public static class EsriInitializer
    {
        private static readonly LicenseInitializer m_AOLicenseInitializer = new LicenseInitializer();

        /// <summary>
        /// esri 所有产品类型
        /// </summary>
        /// <returns></returns>
        private static esriLicenseProductCode[] GetDefaultProductCode()
        {
            return new esriLicenseProductCode[]
                {
                    esriLicenseProductCode.esriLicenseProductCodeAdvanced,
                    esriLicenseProductCode.esriLicenseProductCodeArcServer,
                    esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB,
                    esriLicenseProductCode.esriLicenseProductCodeEngine,
                    esriLicenseProductCode.esriLicenseProductCodeStandard,
                    esriLicenseProductCode.esriLicenseProductCodeBasic,
                };
        }

        /// <summary>
        /// esri所有拓展模块
        /// </summary>
        /// <returns></returns>
        private static esriLicenseExtensionCode[] GetDefaultExtensionCode()
        {
            return new esriLicenseExtensionCode[]
            {
                // 4     ArcPress.
                esriLicenseExtensionCode.esriLicenseExtensionCodeArcPress,
                // 5     TIFF LZW.
                esriLicenseExtensionCode.esriLicenseExtensionCodeTIFFLZW,
                // 6     GeoStatistical Analyst.
                esriLicenseExtensionCode.esriLicenseExtensionCodeGeoStats,
                // 7     Mr SID.
                esriLicenseExtensionCode.esriLicenseExtensionCodeMrSID,
                // 8     Network.
                esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork,
                // 9     3DAnalyst.
                esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst,
                // 10     SpatialAnalyst.
                esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst,
                // 12     StreetMap.
                esriLicenseExtensionCode.esriLicenseExtensionCodeStreetMap,
                // 13     Survey Analyst.
                esriLicenseExtensionCode.esriLicenseExtensionCodeCOGO,
                // 14     Maplex.
                esriLicenseExtensionCode.esriLicenseExtensionCodeMLE,
                // 15     ArcGIS Publisher Extension.
                esriLicenseExtensionCode.esriLicenseExtensionCodePublisher,
                // 31     ArcMapServer Extension.
                esriLicenseExtensionCode.esriLicenseExtensionCodeArcMapServer,
                // 32     Tracking Analyst.
                esriLicenseExtensionCode.esriLicenseExtensionCodeTracking,
                // 33     Business Analyst Standard.
                esriLicenseExtensionCode.esriLicenseExtensionCodeBusinessStandard,
                // 34     ArcScan.
                esriLicenseExtensionCode.esriLicenseExtensionCodeArcScan,
                // 35     Business Analyst Basic.
                esriLicenseExtensionCode.esriLicenseExtensionCodeBusiness,
                // 36     Schematics.
                esriLicenseExtensionCode.esriLicenseExtensionCodeSchematics,
                // 37     Schematics SDK.
                esriLicenseExtensionCode.esriLicenseExtensionCodeSchematicsSDK,
                // 38     Bing Maps VE Engine.
                esriLicenseExtensionCode.esriLicenseExtensionCodeVirtualEarthEng,
                // 39     VBA.
                esriLicenseExtensionCode.esriLicenseExtensionCodeVBAExtension,
                // 40     Workflow Manager.
                esriLicenseExtensionCode.esriLicenseExtensionCodeWorkflowManager,
                // 43     Designer
                esriLicenseExtensionCode.esriLicenseExtensionCodeDesigner,
                // 44     Vector Analyst.
                esriLicenseExtensionCode.esriLicenseExtensionCodeVector,
                // 45     Data Interoperability.
                esriLicenseExtensionCode.esriLicenseExtensionCodeDataInteroperability,
                // 46     Production Mapping.
                esriLicenseExtensionCode.esriLicenseExtensionCodeProductionMapping,
                // 47     Data Reviewer.
                esriLicenseExtensionCode.esriLicenseExtensionCodeDataReViewer,
                // 48     PLTS MPS and Atlas.
                esriLicenseExtensionCode.esriLicenseExtensionCodeMPSAtlas,
                // 49     Defense Mapping.
                esriLicenseExtensionCode.esriLicenseExtensionCodeDefense,
                // 50     Nautical.
                esriLicenseExtensionCode.esriLicenseExtensionCodeNautical,
                // 51     Intelligence Agency.
                esriLicenseExtensionCode.esriLicenseExtensionCodeIntelAgency,
                // 52     PLTS Mapping Agency Solution.
                esriLicenseExtensionCode.esriLicenseExtensionCodeMappingAgency,
                // 53     Aeronautical.
                esriLicenseExtensionCode.esriLicenseExtensionCodeAeronautical,
                // 54     Bing Maps VE.
                esriLicenseExtensionCode.esriLicenseExtensionCodeVirtualEarth,
                // 55     Server Standard Edition.
                esriLicenseExtensionCode.esriLicenseExtensionCodeServerStandardEdition,
                // 56     Server Advanced Edition.
                esriLicenseExtensionCode.esriLicenseExtensionCodeServerAdvancedEdition,
                // 57     Server Enterprise.
                esriLicenseExtensionCode.esriLicenseExtensionCodeServerEnterprise,
                // 58     Image Server Extension.
                esriLicenseExtensionCode.esriLicenseExtensionCodeImageExt,
                // 59     Bing Maps.
                esriLicenseExtensionCode.esriLicenseExtensionCodeBingMaps,
                // 60     Bing Maps Engine.
                esriLicenseExtensionCode.esriLicenseExtensionCodeBingMapsEng,
                // 61     Defense US.
                esriLicenseExtensionCode.esriLicenseExtensionCodeDefenseUS,
                // 62     Defense International.
                esriLicenseExtensionCode.esriLicenseExtensionCodeDefenseINTL,
                // 63     ArcGIS for INSPIRE.
                esriLicenseExtensionCode.esriLicenseExtensionCodeAGINSPIRE,
                // 64     ArcGIS Runtime Basic.
                esriLicenseExtensionCode.esriLicenseExtensionCodeRuntimeBasic,
                // 65     ArcGIS Runtime Standard.
                esriLicenseExtensionCode.esriLicenseExtensionCodeRuntimeStandard,
                // 66     ArcGIS Runtime Advanced.
                esriLicenseExtensionCode.esriLicenseExtensionCodeRuntimeAdvanced,
                // 67     Esri Roads and Highways.
                esriLicenseExtensionCode.esriLicenseExtensionCodeHighways,
                // 68     Video.
                esriLicenseExtensionCode.esriLicenseExtensionCodeVideo,
                // 69     Bathymetry.
                esriLicenseExtensionCode.esriLicenseExtensionCodeBathymetry,
                // 70     Airports.
                esriLicenseExtensionCode.esriLicenseExtensionCodeAirports
            };
        }

        /// <summary>
        /// 初始化Esri产品类型、Esri拓展模块
        /// </summary>
        /// <param name="productCode"></param>
        /// <param name="extensionCode"></param>
        public static void InitializeApplication(esriLicenseProductCode[] productCode = null, esriLicenseExtensionCode[] extensionCode = null)
        {
            Console.Out.WriteLine("InitializeApplication");
            //ESRI License Initializer generated code.
            if (productCode == null)
                productCode = GetDefaultProductCode();
            if (extensionCode == null)
                extensionCode = GetDefaultExtensionCode();

            Console.Out.WriteLine("to InitializeApplication");
            m_AOLicenseInitializer.InitializeApplication(productCode, extensionCode);
        }
        public static void ShutdownApplication()
        {
            m_AOLicenseInitializer.ShutdownApplication();
        }
    }



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

        void BindingArcGISRuntime(object sender, EventArgs e)
        {
            //
            // TODO: Modify ArcGIS runtime binding code as needed
            //
            if (ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop)) return;
            // Failed to bind, announce and force exit
            Console.WriteLine("Invalid ArcGIS runtime binding. Application will shut down.");
            Environment.Exit(0);
        }
        /// <summary>
        /// Raised when ArcGIS runtime binding hasn't been established. 
        /// </summary>
        public event EventHandler ResolveBindingEvent;

        /// <summary>
        /// Initialize the application with the specified product and extension license code.
        /// </summary>    
        /// <returns>Initialization is successful.</returns>
        /// <remarks>
        /// Make sure an active ArcGIS runtime has been bound before license initialization.
        /// </remarks>
        public bool InitializeApplication(esriLicenseProductCode[] productCodes, esriLicenseExtensionCode[] extensionLics)
        {
            //Cache product codes by enum int so can be sorted without custom sorter
            m_requestedProducts = new List<int>();
            foreach (var code in productCodes)
            {
                var requestCodeNum = Convert.ToInt32(code);
                if (!m_requestedProducts.Contains(requestCodeNum))
                {
                    m_requestedProducts.Add(requestCodeNum);
                }
            }
            AddExtensions(extensionLics);

            // Make sure an active runtime has been bound before calling any ArcObjects code. 
            if (ESRI.ArcGIS.RuntimeManager.ActiveRuntime == null)
            {
                var temp = ResolveBindingEvent;
                if (temp != null)
                {
                    temp(this, new EventArgs());
                }
            }

            return Initialize();
        }

        /// <summary>
        /// A summary of the status of product and extensions initialization.
        /// </summary>
        public string LicenseMessage()
        {
            if (ESRI.ArcGIS.RuntimeManager.ActiveRuntime == null)
            {
                return MessageNoRuntimeBinding;
            }

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

            var prodStatus = string.Empty;
            var 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
            {
                //Failed...
                foreach (var item in m_productStatus)
                {
                    prodStatus += ReportInformation(m_AoInit as ILicenseInformation,
                        item.Key, item.Value) + Environment.NewLine;
                }
            }

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

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

        /// <summary>
        /// Shuts down AoInitialize object and check back in extensions to ensure
        /// any ESRI libraries that have been used are unloaded in the correct order.
        /// </summary>
        /// <remarks>Once Shutdown has been called, you cannot re-initialize the product license
        /// and should not make any ArcObjects call.</remarks>
        public void ShutdownApplication()
        {
            if (m_hasShutDown)
                return;

            //Check back in extensions
            if (m_AoInit != null)
            {
                foreach (var 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>
        /// Indicates if the extension is currently checked out.
        /// </summary>
        public bool IsExtensionCheckedOut(esriLicenseExtensionCode code)
        {
            return m_AoInit != null && m_AoInit.IsExtensionCheckedOut(code);
        }

        /// <summary>
        /// Set the extension(s) to be checked out for your ArcObjects code. 
        /// </summary>
        public bool AddExtensions(params esriLicenseExtensionCode[] requestCodes)
        {
            if (m_requestedExtensions == null)
                m_requestedExtensions = new List<esriLicenseExtensionCode>();
            foreach (var code in requestCodes)
            {
                if (!m_requestedExtensions.Contains(code))
                    m_requestedExtensions.Add(code);
            }

            if (m_hasInitializeProduct)
                return CheckOutLicenses(InitializedProduct);

            return false;
        }

        /// <summary>
        /// Check in extension(s) when it is no longer needed.
        /// </summary>
        public void RemoveExtensions(params esriLicenseExtensionCode[] requestCodes)
        {
            if (m_extensionStatus == null || m_extensionStatus.Count == 0)
                return;

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

        /// <summary>
        /// Get/Set the ordering of product code checking. If true, check from lowest to 
        /// highest license. True by default.
        /// </summary>
        public bool InitializeLowerProductFirst
        {
            get
            {
                return m_productCheckOrdering;
            }
            set
            {
                m_productCheckOrdering = value;
            }
        }

        /// <summary>
        /// Retrieves the product code initialized in the ArcObjects application
        /// </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 (ESRI.ArcGIS.RuntimeManager.ActiveRuntime == null)
            {
                Console.Out.WriteLine("ActiveRuntime is null");
                return false;
            }
            if (m_requestedProducts == null || m_requestedProducts.Count == 0)
            {
                Console.Out.WriteLine("RequestedProduct is null");
                return false;
            }
            var productInitialized = false;

            m_requestedProducts.Sort();
            if (!InitializeLowerProductFirst) //Request license from highest to lowest
            {
                Console.Out.WriteLine("InitializeLowerProductFirst failed");
                m_requestedProducts.Reverse();
            }
            m_AoInit = new AoInitializeClass();
            var currentProduct = new esriLicenseProductCode();
            foreach (var prodNumber in m_requestedProducts)
            {
                var prod = (esriLicenseProductCode)Enum.ToObject(typeof(esriLicenseProductCode), prodNumber);
                var status = m_AoInit.IsProductCodeAvailable(prod);
                if (status == esriLicenseStatus.esriLicenseAvailable)
                {
                    status = m_AoInit.Initialize(prod);
                    if (status == esriLicenseStatus.esriLicenseAlreadyInitialized ||
                        status == esriLicenseStatus.esriLicenseCheckedOut)
                    {
                        Console.Out.WriteLine("esriLicenseStatus status");
                        productInitialized = true;
                        currentProduct = m_AoInit.InitializedProduct();
                    }
                }
                if (!m_productStatus.ContainsKey(prod))
                {
                    m_productStatus.Add(prod, status);
                }

                if (productInitialized)
                    break;
            }

            m_hasInitializeProduct = productInitialized;
            m_requestedProducts.Clear();

            //No product is initialized after trying all requested licenses, quit
            if (!productInitialized)
            {
                Console.Out.WriteLine("ProductInitialized failed");
                return false;
            }

            //Check out extension licenses
            return CheckOutLicenses(currentProduct);
        }

        private bool CheckOutLicenses(esriLicenseProductCode currentProduct)
        {
            var allSuccessful = true;
            //Request extensions
            if (m_requestedExtensions != null && currentProduct != 0)
            {
                foreach (var ext in m_requestedExtensions)
                {
                    var licenseStatus = m_AoInit.IsExtensionCodeAvailable(currentProduct, ext);
                    if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)//skip unavailable extensions
                    {
                        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)
        {
            var prodName = string.Empty;
            try
            {
                prodName = licInfo.GetLicenseProductName(code);
            }
            catch
            {
                prodName = code.ToString();
            }

            var 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)
        {
            var extensionName = string.Empty;
            try
            {
                extensionName = licInfo.GetLicenseExtensionName(code);
            }
            catch
            {
                extensionName = code.ToString();
            }

            var 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

        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";

        #region Private members

        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; //default from low to high
        #endregion
    }
    #endregion