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);
}
public static void AoInitialize()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
IAoInitialize pAoInitialize = new AoInitializeClass();
if (pAoInitialize == null)
{
throw new Exception("AO Initialize failed");
}
esriLicenseStatus status = pAoInitialize.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
if (status == esriLicenseStatus.esriLicenseAvailable)
{
pAoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
}
else if (status == esriLicenseStatus.esriLicenseUnavailable)
{
throw new Exception("esriLicenseProductCodeAdvanced is unavailable");
}
//status = pAoInitialize.IsExtensionCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeAdvanced, esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst);
//if (status == esriLicenseStatus.esriLicenseAvailable)
//{
// status = pAoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst);
// if (status == esriLicenseStatus.esriLicenseNotInitialized) { throw new Exception("esriLicenseExtensionCodeSpatialAnalyst is not initialized"); }
//}
//else if (status == esriLicenseStatus.esriLicenseNotLicensed) { throw new Exception("esriLicenseExtensionCodeSpatialAnalyst is not licensed"); }
//else if (status == esriLicenseStatus.esriLicenseUnavailable) { throw new Exception("esriLicenseExtensionCodeSpatialAnalyst is unavailable"); }
}
static void Main()
{
//指定arcgis 版本
if (!RuntimeManager.Bind(ProductCode.Engine))
{
MessageBox.Show("未找到Arcgis Engine。");
return;
}
//初始化Arcgis授权
AoInitialize init = new AoInitialize();
esriLicenseStatus status = init.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
//程序初始化
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
//Application.Run(new FormBdcMain());
FormLogin loginForm = new FormLogin();
if (loginForm.ShowDialog() == DialogResult.OK)
{
Application.Run(new FormMain());
}
else
{
Application.Exit();
}
}
private void Intersection_Load(object sender, EventArgs e)
{
switch (operationType)
{
case "intersection":
this.Text = "求交";
break;
case "union":
this.Text = "求和";
break;
case "clip":
this.Text = "擦除";
break;
case "xor":
this.Text = "异或";
break;
}
IAoInitialize m_AoInitialize = new AoInitializeClass();
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
licenseStatus = m_AoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
for (int i = 0; i < pMap.LayerCount; i++)
{
cbInputLayer.Items.Add(pMap.get_Layer(i).Name);
}
for (int i = 0; i < pMap.LayerCount; i++)
{
cbOverLayLayer.Items.Add(pMap.get_Layer(i).Name);
}
}
/// <summary>
/// Default constructor
/// </summary>
public WmauAbstractGpFunction()
{
// WORKAROUND: Encountered a problem where the background GP tools did not
// appear to be checking out the extension licenses soon enough for the
// admin utilities. The problem arose when a utility would try to access
// the WMX database to determine what its parameter domains should be, but
// the WMX license wasn't yet checked out... so the tool's ParameterInfo
// method would fail.
//
// By trying to check out the extension here, we can work around this problem
// and (hopefully) not introduce any licensing problems elsewhere.
if (WmauAbstractGpFunction.m_aoInit == null)
{
WmauAbstractGpFunction.m_aoInit = new AoInitializeClass();
esriLicenseStatus wmxLicenseStatus =
WmauAbstractGpFunction.m_aoInit.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeWorkflowManager);
if (wmxLicenseStatus == esriLicenseStatus.esriLicenseFailure ||
wmxLicenseStatus == esriLicenseStatus.esriLicenseNotLicensed ||
wmxLicenseStatus == esriLicenseStatus.esriLicenseUnavailable)
{
throw new WmauException(WmauErrorCodes.C_LICENSE_RELATED_ERROR);
}
}
// END WORKAROUND
m_gpTrue = new GPBooleanClass();
m_gpTrue.Value = true;
m_gpFalse = new GPBooleanClass();
m_gpFalse.Value = false;
}
private string LicenseMessage(esriLicenseStatus licenseStatus)
{
string message = "";
//Not licensed
if (licenseStatus == esriLicenseStatus.esriLicenseNotLicensed)
{
message = "You are not licensed to run this product!";
}
//The licenses needed are currently in use
else if (licenseStatus == esriLicenseStatus.esriLicenseUnavailable)
{
message = "There are insuffient licenses to run!";
}
//The licenses unexpected license failure
else if (licenseStatus == esriLicenseStatus.esriLicenseFailure)
{
message = "Unexpected license failure! Please contact your administrator.";
}
//Already initialized (Initialization can only occur once)
else if (licenseStatus == esriLicenseStatus.esriLicenseAlreadyInitialized)
{
message = "The license has already been initialized! Please check your implementation.";
}
return(message);
}
private string LicenseMessage(esriLicenseStatus licenseStatus)
{
string message = "";
//没有许可
if (licenseStatus == esriLicenseStatus.esriLicenseNotInitialized)
{
message = "You are not licensed to run this product!";
}
//许可正在使用
else if (licenseStatus == esriLicenseStatus.esriLicenseUnavailable)
{
message = "There are insuffient licenses to run!";
}
//未知错误
else if (licenseStatus == esriLicenseStatus.esriLicenseFailure)
{
message = "Unexpected license failure! Please contact your administrator.";
}
//已经初始化
else if (licenseStatus == esriLicenseStatus.esriLicenseAlreadyInitialized)
{
message = "The license has already been initialized! Please check your implementation.";
}
return(message);
}
private bool CheckOutLicenses(esriLicenseProductCode currentProduct)
{
bool allSuccessful = true;
//Request extensions
if (m_requestedExtensions != null && currentProduct != 0)
{
foreach (esriLicenseExtensionCode ext in m_requestedExtensions)
{
esriLicenseStatus 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);
}
public bool InitializeApplication()
{
bool bInitialized = true;
if (m_AoInitialize == null)
{
System.Windows.Forms.MessageBox.Show("Unable to initialize. This application cannot run!");
bInitialized = false;
}
//初始化应用程序
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
licenseStatus = CheckOutLicenses(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
licenseStatus = CheckOutLicenses(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
licenseStatus = CheckOutLicenses(esriLicenseProductCode.esriLicenseProductCodeStandard);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
licenseStatus = CheckOutLicenses(esriLicenseProductCode.esriLicenseProductCodeBasic);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
System.Windows.Forms.MessageBox.Show(LicenseMessage(licenseStatus));
bInitialized = false;
}
}
}
}
return(bInitialized);
}
/// <summary>
/// 初始化地图
/// </summary>
internal static void InitMap()
{
if (IsInitedMap)
{
return; //如果已初化则返回
}
//绑定arcgis运行时
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
IAoInitialize pAoInitialize = new AoInitializeClass();
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
licenseStatus = pAoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
//if (!ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Engine))
//{
if (!ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop))
{
System.Windows.Forms.MessageBox.Show("This application could not load the correct version of ArcGIS.");
return;
}
//}
//获取engine网络分析权限
//Map.LicenseInitializer aoLicenseInitializer = new Map.LicenseInitializer();
//if (!aoLicenseInitializer.InitializeApplication(new esriLicenseProductCode[] { esriLicenseProductCode.esriLicenseProductCodeEngine, esriLicenseProductCode.esriLicenseProductCodeBasic, esriLicenseProductCode.esriLicenseProductCodeStandard, esriLicenseProductCode.esriLicenseProductCodeAdvanced },
//new esriLicenseExtensionCode[] { esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork,esriLicenseExtensionCode.esriLicenseExtensionCodeDataInteroperability, esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst }))
//{
// System.Windows.Forms.MessageBox.Show("This application could not initialize with the correct ArcGIS license and will shutdown. LicenseMessage: " + aoLicenseInitializer.LicenseMessage());
// aoLicenseInitializer.ShutdownApplication();
// return;
//}
IsInitedMap = true;
}
/// <summary>
/// Check out spatial analyst license
/// </summary>
/// <returns>esriLicenseStatus</returns>
public esriLicenseStatus GetSpatialAnalystLicense()
{
//Check out a Spatial Analyst license with the ArcView product.
esriLicenseProductCode productCode =
esriLicenseProductCode.esriLicenseProductCodeAdvanced;
IAoInitialize pAoInitialize = new AoInitializeClass();
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
//Check the productCode.
licenseStatus = pAoInitialize.IsProductCodeAvailable(productCode);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
//Check the extensionCode.
licenseStatus = pAoInitialize.IsExtensionCodeAvailable(productCode,
esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
//Initialize the license.
licenseStatus = pAoInitialize.Initialize(productCode);
if ((licenseStatus == esriLicenseStatus.esriLicenseCheckedOut))
{
//Check out the Spatial Analyst extension.
licenseStatus = pAoInitialize.CheckOutExtension
(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst)
;
}
}
}
return(licenseStatus);
}
static void Main()
{
if (!RuntimeManager.Bind(ProductCode.Engine))
{
if (!RuntimeManager.Bind(ProductCode.Desktop))
{
MessageBox.Show("Unable to bind to ArcGIS runtime. Application will be shut down.");
return;
}
}
IAoInitialize m_AoInitialize = new AoInitializeClass();
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
licenseStatus = m_AoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
if (licenseStatus == esriLicenseStatus.esriLicenseNotInitialized)
{
MessageBox.Show("没有esriLicenseProductCodeArcInfo许可！");
Application.Exit();
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
}
/// <summary>
/// 初始化许可
/// </summary>
/// <returns></returns>
public bool CheckLicenses()
{
if (m_AoInitialize == null)
{
MessageBox.Show("不能初始化", "ArcGIS Engine许可错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
esriLicenseStatus licenseStatus = (esriLicenseStatus)m_AoInitialize.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = (esriLicenseStatus)m_AoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
if (licenseStatus != esriLicenseStatus.esriLicenseAlreadyInitialized)
{
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
MessageBox.Show("初始化失败，应用程序不能运行!", "ArcGIS Engine许可错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
}
else
{
MessageBox.Show("程序运行期间重复初始化！");
}
}
else
{
MessageBox.Show("初始化失败，应用程序不能运行!", "ArcGIS Engine许可错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
return(true);
}
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) //Request license from highest to lowest
{
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();
//No product is initialized after trying all requested licenses, quit
if (!productInitialized)
{
return(false);
}
//Check out extension licenses
return(CheckOutLicenses(currentProduct));
}
private esriLicenseStatus CheckOutLicenses()
{
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseNotInitialized;
//Determine if the product is available
for (int i = 0; i < m_productsCode.Length; i++)
{
esriLicenseProductCode pc = m_productsCode[i];
licenseStatus = m_AoInitialize.IsProductCodeAvailable(pc);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = m_AoInitialize.Initialize(pc);
if (licenseStatus == esriLicenseStatus.esriLicenseCheckedOut)
{
m_initProduct = pc;
break;
}
}
}
if (m_pExtensionsCode != null)
{
//Checkout the extensions - only when product is initialized
if (licenseStatus == esriLicenseStatus.esriLicenseCheckedOut)
{
System.Collections.ArrayList initExts = new System.Collections.ArrayList(m_pExtensionsCode.Length);
foreach (esriLicenseExtensionCode extLicense in m_pExtensionsCode)
{
//Determine if the extensions are available - some may not be available depending on the product initialized
//If so, initialization fails...
licenseStatus = m_AoInitialize.IsExtensionCodeAvailable(m_initProduct, extLicense);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = m_AoInitialize.CheckOutExtension(extLicense);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut && licenseStatus != esriLicenseStatus.esriLicenseAlreadyInitialized)
{
break;
}
//Add to license initialized list
initExts.Add(extLicense);
}
else
{
break; //Exit when failed to check out any extension
}
}
if (initExts.Count > 0)
{
m_initExts = new esriLicenseExtensionCode[initExts.Count];
m_initExts = (esriLicenseExtensionCode[])initExts.ToArray(typeof(esriLicenseExtensionCode));
}
}
}
return(licenseStatus);
}
static void Main(string[] args)
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
IAoInitialize aoInit = new AoInitialize();
esriLicenseStatus licStat = aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngine);
licStat = aoInit.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst);
CreateMathFunctionRasterDataset();
aoInit.Shutdown();
}
/// <summary>
/// 绑定lincense
/// </summary>
public void BindArcgisLicense()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
IAoInitialize _iAoInitialize = new AoInitializeClass();
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
licenseStatus = _iAoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
//licenseStatus = _iAoInitialize.(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
licenseStatus = _iAoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeDataInteroperability);
licenseStatus = _iAoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
}
public static bool LoadAdvanceLicense(bool isLoadSpatialAnalyst, bool isLoadCodeNetwork, out string ErrorMessage)
{
bool result = true;
ErrorMessage = "";
//检测ArcGIS授权
if (!RuntimeManager.Bind(ProductCode.EngineOrDesktop))
{
ErrorMessage = "请确认ArcGIS的许可安装正确有效！";
return(false);
}
IAoInitialize aoInitialize = new AoInitialize();
try
{
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
licenseStatus = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
licenseStatus = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
ErrorMessage = "获取ARCGIS授权失败";
return(false);
}
}
////盗版使用的授权
licenseStatus = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeArcServer);
// 迁出空间分析扩展模块
if (isLoadSpatialAnalyst)
{
if (aoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst) != esriLicenseStatus.esriLicenseCheckedOut)
{
ErrorMessage = "获取空间分析扩展模块授权失败！";
return(false);
}
}
// 迁出网络分析扩展模块
if (isLoadCodeNetwork)
{
if (aoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork) != esriLicenseStatus.esriLicenseCheckedOut)
{
ErrorMessage = "获取网络分析扩展模块授权失败！";
return(false);
}
}
}
catch (Exception ex)
{
result = false;
ErrorMessage = ex.Message;
}
return(result);
}
public OverlayAnalysis(AxMapControl axMapControl, string cmd)
{
IAoInitialize aoInitialize = new AoInitialize();
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
licenseStatus = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
InitializeComponent();
axMapControl1 = axMapControl;
pMap = axMapControl1.Map;
operationType = cmd;
}
static void Main()
{
// Bind this ArcObjects application to this machine's ArcGIS license
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
// Fetch the License
ESRI.ArcGIS.esriSystem.IAoInitialize ao = new ESRI.ArcGIS.esriSystem.AoInitialize();
esriLicenseStatus status = ao.Initialize(ESRI.ArcGIS.esriSystem.esriLicenseProductCode.esriLicenseProductCodeStandard);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
public esriLicenseStatus CheckinExtension(esriLicenseExtensionCode extensionCode)
{
esriLicenseStatus status = _aoInitialize.CheckInExtension(extensionCode);
if (status == esriLicenseStatus.esriLicenseCheckedIn)
{
if (_initializedExtensions != null)
{
_initializedExtensions.Remove(extensionCode);
}
}
return(status);
}
public MainForm()
{
#region 初始化许可
IAoInitialize m_AoInitialize = new AoInitializeClass();
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
licenseStatus = m_AoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeArcInfo);
//默认第一个为有效地，之后无效，此级别最高，可用绝大多数功能
////licenseStatus = m_AoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngine);级别最低
#endregion
InitializeComponent();
}
private bool InitializeProduct(esriLicenseProductCode productCode)
{
esriLicenseStatus status = m_pAoInit.IsProductCodeAvailable(productCode);
if (status == esriLicenseStatus.esriLicenseAvailable)
{
status = m_pAoInit.Initialize(productCode);
if (status == esriLicenseStatus.esriLicenseCheckedOut ||
status == esriLicenseStatus.esriLicenseAlreadyInitialized)
{
return(true);
}
}
return(false);
}
private esriLicenseStatus InitializeLicense()
{
esriLicenseStatus LicenseStatus = esriLicenseStatus.esriLicenseUnavailable;
LicenseStatus = init.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeBasic);
if (LicenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
LicenseStatus = init.Initialize(esriLicenseProductCode.esriLicenseProductCodeBasic);
}
else
{
LicenseStatus = esriLicenseStatus.esriLicenseUnavailable;
}
return(LicenseStatus);
}
static void Main()
{
#region 获取License
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
IAoInitialize aoInitialize = new AoInitialize();
licenseStatus = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
#endregion
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
static void AoInitializeFirst()
{
try
{
m_AoInitialize = new AoInitializeClass();
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
licenseStatus = m_AoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
m_AoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst);
}
catch (Exception ex)
{
throw new ApplicationException("ArcEngine 不能正常初始化许可");
}
}
/// <summary>
/// This is used to return whether the function tool is licensed to execute.
/// </summary>
/// <remarks>Override to provide custom licensing check</remarks>
/// <returns></returns>
public virtual bool IsLicensed()
{
IAoInitialize aoi = new AoInitializeClass();
esriLicenseStatus status = aoi.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeWorkflowManager);
if (status == esriLicenseStatus.esriLicenseCheckedOut ||
status == esriLicenseStatus.esriLicenseAlreadyInitialized ||
status == esriLicenseStatus.esriLicenseAvailable)
{
return(true);
}
else
{
return(false);
}
}
static void Main()
{
//绑定运行时
ESRI.ArcGIS.RuntimeManager.Bind(ProductCode.Engine);
IAoInitialize m_AoInitialize = new AoInitializeClass();
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
//初始化engineGeoDB许可
licenseStatus = m_AoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
//检出扩展许可
//licenseStatus = m_AoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
private static bool checkLicense()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
IAoInitialize m_AoInitialize = new AoInitialize();
esriLicenseStatus licenseStatus = (esriLicenseStatus)m_AoInitialize.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeEngine);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = (esriLicenseStatus)m_AoInitialize.IsExtensionCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeEngine, esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = (esriLicenseStatus)m_AoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);//esriLicenseProductCodeEngine);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
XtraMessageBox.Show("The initialization failed. This application cannot run!");
return(false);
}
else
{
licenseStatus = (esriLicenseStatus)m_AoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeDesigner);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
XtraMessageBox.Show("Unable to check out the Designer extension. This application cannot run!");
return(false);
}
else
{
licenseStatus = (esriLicenseStatus)m_AoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
XtraMessageBox.Show("Unable to check out the Designer extension. This application cannot run!");
return(false);
}
}
}
}
return(true);
}
else
{
XtraMessageBox.Show("The ArcGIS Engine product is unavailable. This application cannot run!");
return(false);
}
}
public bool IsLicensed()
{
// check for a Network Analyst license
IAoInitialize aoInitialize = new AoInitializeClass();
ILicenseInformation licInfo = (ILicenseInformation)aoInitialize;
esriLicenseStatus licenseStatus = aoInitialize.IsExtensionCodeAvailable(aoInitialize.InitializedProduct(), esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork);
bool isLicensed = false;
if (licenseStatus != esriLicenseStatus.esriLicenseUnavailable)
{
isLicensed = true;
}
return(isLicensed);
}
private string LicenseMessage(esriLicenseStatus licenseStatus)
{
string message = "";
//Not licensed
if (licenseStatus == esriLicenseStatus.esriLicenseNotLicensed)
{
message = "You are not licensed to run this product!";
}
//The licenses needed are currently in use
else if (licenseStatus == esriLicenseStatus.esriLicenseUnavailable)
{
message = "There are insuffient licenses to run!";
}
//The licenses unexpected license failure
else if (licenseStatus == esriLicenseStatus.esriLicenseFailure)
{
message = "Unexpected license failure! Please contact your administrator.";
}
//Already initialized (Initialization can only occur once)
else if (licenseStatus == esriLicenseStatus.esriLicenseAlreadyInitialized)
{
message = "The license has already been initialized! Please check your implementation.";
}
return message;
}
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;
}
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;
}
