protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
// Binding to ArcGIS Desktop
RuntimeManager.Bind(ProductCode.Desktop);
// Get ESRI License
this._aoInitialize = new AoInitializeClass();
esriLicenseProductCode[] codes = new esriLicenseProductCode[] {
esriLicenseProductCode.esriLicenseProductCodeStandard,
esriLicenseProductCode.esriLicenseProductCodeAdvanced
};
bool ok = false;
foreach (esriLicenseProductCode code in codes) {
if (this._aoInitialize.IsProductCodeAvailable(code) == esriLicenseStatus.esriLicenseAvailable) {
if (this._aoInitialize.Initialize(code) == esriLicenseStatus.esriLicenseCheckedOut) {
ok = true;
break;
}
}
}
if (!ok) {
MessageBox.Show("Unable to checkout Esri license", "Zeta", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
/// <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 (esriLicenseProductCode code in productCodes)
{
int 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 (RuntimeManager.ActiveRuntime == null)
{
EventHandler temp = ResolveBindingEvent;
if (temp != null)
{
temp(this, new EventArgs());
}
}
return Initialize();
}
/// <summary>
/// Initialize the application with the specified product and extension license code.
/// </summary>
/// <returns>Initialization is successful.</returns>
/// <remarks>
/// If no active runtime has been bound to the application before license initialization
/// takes place, the ResolveBindingEvent is raised.
/// </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 (esriLicenseProductCode code in productCodes)
{
int requestCodeNum = Convert.ToInt32(code);
if (!m_requestedProducts.Contains(requestCodeNum))
{
m_requestedProducts.Add(requestCodeNum);
}
}
AddExtensions(extensionLics);
// Make sure an active version has been loaded before calling any ArcObjects code.
RuntimeInfo boundRuntime = RuntimeManager.ActiveRuntime;
if (boundRuntime != null &&
(this.AllowImplicitRuntimeBinding || boundRuntime.Product > ProductCode.ArcGIS))
{
m_AoInit = new AoInitializeClass();
}
else
{
EventHandler temp = ResolveBindingEvent;
if (temp != null)
{
temp(this, new EventArgs());
if (RuntimeManager.ActiveRuntime != null)
m_AoInit = new AoInitializeClass();
}
}
return Initialize();
}
public void InitializeApplication(esriLicenseProductCode[] products,esriLicenseExtensionCode [] extensions)
{
// Binding a product
RuntimeManager.Bind(ProductCode.EngineOrDesktop);
// Initialize a product code
m_AoInit = new AoInitializeClass();
esriLicenseProductCode currentProduct = new esriLicenseProductCode();
foreach (esriLicenseProductCode prod in products)
{
esriLicenseStatus prodStatus = m_AoInit.IsProductCodeAvailable(prod);
if(prodStatus==esriLicenseStatus.esriLicenseAvailable)
{
prodStatus=m_AoInit.Initialize(prod);
if(prodStatus==esriLicenseStatus.esriLicenseAlreadyInitialized||prodStatus==esriLicenseStatus.esriLicenseCheckedOut)
{
currentProduct = prod;
}
}
}
if(m_AoInit.InitializedProduct()!=null)
{
foreach (esriLicenseExtensionCode ext in extensions)
{
m_RequetedExtensionCodes.Add(ext);
esriLicenseStatus extStatus = m_AoInit.IsExtensionCodeAvailable(currentProduct,ext);
if (extStatus == esriLicenseStatus.esriLicenseAvailable)
m_AoInit.CheckOutExtension(ext);
}
}
}
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);
}
/// <summary>
/// Converts the array of arguments to the strongly type object and executes the program while checking
/// out the ArcFM and ESRI licenses
/// </summary>
/// <param name="args">The arguments.</param>
/// <param name="esriLicenseProduct">The esri license product.</param>
/// <returns>
/// Returns a <see cref="bool" /> representing 0 for success and failure any other value.
/// </returns>
public virtual int Run(string[] args, esriLicenseProductCode esriLicenseProduct)
{
Stopwatch stopwatch = Stopwatch.StartNew();
try
{
Console.Title = Application.ProductName;
Log.Info("===============================");
Log.Info(Application.ProductName + " Started.");
Log.Info("Version: " + Application.ProductVersion);
Log.Info("User: "******"===============================");
Log.Info("");
if (args == null || args.Length == 0)
{
args = this.CreateArguments();
}
Log.Info($"Arguments: {string.Join(" ", args)}");
Log.Info("");
TProgramArguments o = this.ParseArguments(args);
if (this.Initialize(o))
{
using (EsriRuntimeAuthorization lic = new EsriRuntimeAuthorization())
{
if (!lic.Initialize(esriLicenseProduct))
{
Log.Error(lic.GetInitializationStatus());
return(-1);
}
else
{
Log.Info(lic.GetInitializationStatus());
}
return((this.Execute(o)) ? 1 : 0);
}
}
return(0);
}
catch (Exception ex)
{
Log.Error(ex);
return(-1);
}
finally
{
Log.Info("");
Log.Info("Elapsed time was: {0}:{1}:{2}.{3}", stopwatch.Elapsed.Hours, stopwatch.Elapsed.Minutes, stopwatch.Elapsed.Seconds, stopwatch.Elapsed.Milliseconds);
}
}
private bool Initialize()
{
if (m_requestedProducts == null || m_requestedProducts.Count == 0)
{
return(false);
}
esriLicenseProductCode currentProduct = new esriLicenseProductCode();
bool productInitialized = false;
//Try to initialize a product
ILicenseInformation licInfo = (ILicenseInformation)m_AoInit;
m_requestedProducts.Sort();
if (!InitializeLowerProductFirst) //Request license from highest to lowest
{
m_requestedProducts.Reverse();
}
foreach (int prodNumber in m_requestedProducts)
{
esriLicenseProductCode prod = (esriLicenseProductCode)Enum.ToObject(typeof(esriLicenseProductCode), prodNumber);
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
//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 static void InitializeEngineLicense()
{
AoInitialize aoInitialize = new AoInitializeClass();
const esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeArcInfo;
if (aoInitialize.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoInitialize.Initialize(productCode);
}
}
public void InitArcGISLicence()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
AoInitialize aoi = new AoInitializeClass();
esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeAdvanced;
if (aoi.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoi.Initialize(productCode);
}
}
private void InitializeEngineLicense()
{
AoInitialize aoi = new AoInitializeClass();
//more license choices could be included here
esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeEngine;
if (aoi.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoi.Initialize(productCode);
}
}
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;
}
private esriLicenseStatus CheckOutLicenses(esriLicenseProductCode productCode)
{
esriLicenseStatus licenseStatus;
//是否产品是可能的
licenseStatus = m_AoInitialize.IsProductCodeAvailable(productCode);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
//用相应的许可文件进行初始化
licenseStatus = m_AoInitialize.Initialize(productCode);
}
return(licenseStatus);
}
private void InitializeEngineLicense()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Engine);
AoInitialize aoi = new AoInitializeClass();
//more license choices could be included here
esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeEngine;
if (aoi.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoi.Initialize(productCode);
}
}
private static ProductCode GetProductCode(esriLicenseProductCode licenseProductCode)
{
switch (licenseProductCode)
{
case esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB:
case esriLicenseProductCode.esriLicenseProductCodeEngine:
return(ProductCode.Engine);
case esriLicenseProductCode.esriLicenseProductCodeArcServer:
return(ProductCode.Server);
default:
return(ProductCode.Desktop);
}
}
public MapControlAgent()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
IAoInitialize aoInit = new AoInitializeClass();
esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB;
if (aoInit.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoInit.Initialize(productCode);
}
mapCtrl = new AxMapControl();
mapCtrl.OnDoubleClick += MapCtrl_OnDoubleClick;
}
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 bool m_productCheckOrdering = true; //default from low to high
#endregion
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 (esriLicenseProductCode code in productCodes)
{
int requestCodeNum = Convert.ToInt32(code);
if (!m_requestedProducts.Contains(requestCodeNum))
{
m_requestedProducts.Add(requestCodeNum);
}
}
AddExtensions(extensionLics);
return Initialize();
}
private void InitializeEngineLicense()
{
try
{
AoInitialize aoi = new AoInitializeClass();
const esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeAdvanced;
if (aoi.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoi.Initialize(productCode);
}
}
catch (Exception e)
{
_log.Fatal(e.Message);
}
}
public static void initlicense()
{
AoInitialize aoi = new AoInitialize();
esriLicenseExtensionCode extensionCodes = esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst; //这是解决的办法
esriLicenseExtensionCode extensionCode = esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst;
esriLicenseProductCode pro = esriLicenseProductCode.esriLicenseProductCodeEngine;
if (aoi.IsProductCodeAvailable(pro) == esriLicenseStatus.esriLicenseAvailable &&
aoi.IsExtensionCodeAvailable(pro, extensionCode) == esriLicenseStatus.esriLicenseAvailable &&
aoi.IsExtensionCodeAvailable(pro, extensionCodes) == esriLicenseStatus.esriLicenseAvailable
)
{
aoi.Initialize(pro);
aoi.CheckOutExtension(extensionCode);
aoi.CheckOutExtension(extensionCodes);
}
}
public static IAoInitialize CheckoutESRILicense(esriLicenseProductCode pESRIProdCode)
{
ESRI.ArcGIS.RuntimeManager.BindLicense(ESRI.ArcGIS.ProductCode.Desktop); // SET A REFERENCE TO THE ESRI DESKTOP APPLICATION
var license = new AoInitializeClass(); // INSTANTIATE THE LICENSE
esriLicenseStatus pLicenseStatus = (esriLicenseStatus)license.IsProductCodeAvailable(pESRIProdCode); // DETERMINE THE STATUS OF THE REQUESTED LICENSE
if (pLicenseStatus == esriLicenseStatus.esriLicenseCheckedOut) { return license; } // RETURN IF A LICENSE IS ALREADY CHECKED OUT
if (pLicenseStatus == esriLicenseStatus.esriLicenseAvailable) // DETERMINE IF A LICENSE IS AVAILABLE
{
pLicenseStatus = (esriLicenseStatus)license.Initialize(pESRIProdCode);
if (pLicenseStatus == esriLicenseStatus.esriLicenseCheckedOut || pLicenseStatus == esriLicenseStatus.esriLicenseAlreadyInitialized)
return license;
}
return null;
}
public bool InitializeApplication(esriLicenseProductCode[] productCodes, esriLicenseExtensionCode[] extensionLics)
{
bool bInitialized = true;
if (m_AoInitialize == null)
{
bInitialized = false;
}
//Initialize the application
esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
m_productsCode = productCodes;
m_pExtensionsCode = extensionLics;
licenseStatus = CheckOutLicenses();
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
bInitialized = false;
}
return bInitialized;
}
private bool InitializeEngineLicense()
{
AoInitialize aoi = new AoInitializeClass();
//more license choices could be included here
esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeEngine;
esriLicenseExtensionCode extensionCode = esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst;
if (aoi.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable && aoi.IsExtensionCodeAvailable(productCode, extensionCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoi.Initialize(productCode);
aoi.CheckOutExtension(extensionCode);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Determine extension state
/// </summary>
/// <param name="requestEnable">true if to enable; false to disable</param>
private esriExtensionState StateCheck(bool requestEnable)
{
//Turn on or off extension directly
if (requestEnable)
{
//Check if the correct product is licensed
IAoInitialize aoInitTestProduct = new AoInitializeClass();
esriLicenseProductCode prodCode = aoInitTestProduct.InitializedProduct();
if (prodCode == RequiredProductCode)
{
return(esriExtensionState.esriESEnabled);
}
return(esriExtensionState.esriESUnavailable);
}
else
{
return(esriExtensionState.esriESDisabled);
}
}
//签出产品许可
private bool CheckOutLicenseMain(esriLicenseProductCode code)
{
try
{
if (m_AoInitializeClass.IsProductCodeAvailable(code) == esriLicenseStatus.esriLicenseAvailable)
{
if (m_AoInitializeClass.Initialize(code) == esriLicenseStatus.esriLicenseCheckedOut)
{
m_AoInitializeClass.InitializedProduct();
return(true);
}
}
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex.Message);
}
return(false);
}
private static bool InitLicense()
{
//m_pAoInitialize = new AoInitializeClass();
//if (m_pAoInitialize == null)
//{
// return false;
//}
esriLicenseProductCode[] codeArray2 = new esriLicenseProductCode[]
{
esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB,
esriLicenseProductCode.esriLicenseProductCodeEngine,
esriLicenseProductCode.esriLicenseProductCodeArcServer,
esriLicenseProductCode.esriLicenseProductCodeAdvanced
};
esriLicenseStatus esriLicenseNotLicensed = esriLicenseStatus.esriLicenseNotLicensed;
for (int i = 0; i < codeArray2.Length; i++)
{
esriLicenseNotLicensed = m_pAoInitialize.IsProductCodeAvailable(codeArray2[i]);
if (esriLicenseNotLicensed == esriLicenseStatus.esriLicenseAvailable)
{
esriLicenseNotLicensed = m_pAoInitialize.Initialize(codeArray2[i]);
break;
}
}
switch (esriLicenseNotLicensed)
{
case esriLicenseStatus.esriLicenseNotLicensed:
MessageBox.Show("无ArcGIS Engine使用权限!");
return(false);
}
esriLicenseNotLicensed =
m_pAoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst);
esriLicenseNotLicensed =
m_pAoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork);
esriLicenseNotLicensed =
m_pAoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst);
esriLicenseNotLicensed =
m_pAoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeDataInteroperability);
return(true);
}
} // constructor
public void initLic()
{
try {
IAoInitialize ini = new AoInitializeClass();
mLicInit = ini;
esriLicenseProductCode pCode =
esriLicenseProductCode.esriLicenseProductCodeArcServer;
// work on cli: esriLicenseProductCode.esriLicenseProductCodeArcView;
// work on srv: esriLicenseProductCode.esriLicenseProductCodeArcServer;
esriLicenseStatus licstat = ini.Initialize(pCode);
Log.p("Lic.stat is [" + licstat + "]");
if (licstat == esriLicenseStatus.esriLicenseAlreadyInitialized ||
licstat == esriLicenseStatus.esriLicenseAvailable ||
licstat == esriLicenseStatus.esriLicenseCheckedOut)
{
//good
Log.p("Lic.available");
}
else
{
//bad
Log.p("Lic.not available, try another");
pCode = esriLicenseProductCode.esriLicenseProductCodeArcView;
licstat = ini.Initialize(pCode);
Log.p("Lic.stat2 is [" + licstat + "]");
}
if (ini.InitializedProduct() == pCode)
{
Log.p("OK, have good lic.");
}
else
{
Log.p("prod.code is [" + pCode + "] but inited prod.code is [" +
ini.InitializedProduct() + "]");
}
}
catch (Exception e) {
Log.p("ERR, initLic exception: " + e.Message);
throw e;
}
} // initLic method
/// <summary>
/// 初始化产品，只初始化第一个
/// </summary>
/// <returns></returns>
public bool InitializeProduct()
{
if (RuntimeManager.ActiveRuntime == null)
return false;
if (productCodeList == null || extensionCodeList.Count == 0)
return false;
bool productInitialized = false;
productCodeList.Sort();//对于产品集合进行排序
if (!InitializeLowerProductFirst)
{
productCodeList.Reverse();//反转整个集合
}
aoInitialize = new AoInitializeClass();
esriLicenseProductCode currentProductCode = new esriLicenseProductCode();
foreach (int item in productCodeList)
{
esriLicenseProductCode proCode = (esriLicenseProductCode)Enum.ToObject(typeof(esriLicenseProductCode), item);
esriLicenseStatus status = aoInitialize.IsProductCodeAvailable(proCode);
if (status == esriLicenseStatus.esriLicenseAvailable)
{
status = aoInitialize.Initialize(proCode);
if (status == esriLicenseStatus.esriLicenseAlreadyInitialized || status == esriLicenseStatus.esriLicenseCheckedOut)
{
productInitialized = true;
currentProductCode = aoInitialize.InitializedProduct();
}
}
dic_ProductStatus.Add(proCode, status);
if (productInitialized)
break;//只初始化第一个成功的产品！
}
this.hasInitialProduct = productInitialized;
this.productCodeList.Clear();
if (!productInitialized)//如果所有的产品都不成功
return false;
return CheckOutLicense(currentProductCode);//验证扩展
}
private static AoInitialize GetLicense(ProductCode product, esriLicenseProductCode level)
{
AoInitialize aoInit;
try
{
Trace.TraceInformation($"Obtaining {product}-{level} license");
RuntimeManager.Bind(product);
aoInit = new AoInitialize();
esriLicenseStatus licStatus = aoInit.Initialize(level);
Message = $"Ready with license. Status: {licStatus}";
Trace.TraceInformation(Message);
}
catch (Exception ex)
{
Stop();
// Set Message after stop, because stop sets message to null
Message = $"Fatal Error: {ex.Message}";
return(null);
}
return(aoInit);
}
private static esriLicenseStatus CheckOutLicenses(esriLicenseProductCode esriLicenseProductCode_0,
esriLicenseExtensionCode esriLicenseExtensionCode_0)
{
if (m_pAoInitialize == null)
{
// m_pAoInitialize = new AoInitializeClass();
}
esriLicenseStatus status = m_pAoInitialize.IsProductCodeAvailable(esriLicenseProductCode_0);
if (status == esriLicenseStatus.esriLicenseAvailable)
{
status = m_pAoInitialize.IsExtensionCodeAvailable(esriLicenseProductCode_0, esriLicenseExtensionCode_0);
if (status == esriLicenseStatus.esriLicenseAvailable)
{
status = m_pAoInitialize.Initialize(esriLicenseProductCode_0);
if (status == esriLicenseStatus.esriLicenseCheckedOut)
{
status = m_pAoInitialize.CheckOutExtension(esriLicenseExtensionCode_0);
}
}
}
return(status);
}
//签出产品许可
public static bool CheckOutLicenseMain(esriLicenseProductCode code)
{
try
{
if (m_AoInitializeClass.IsProductCodeAvailable(code) == esriLicenseStatus.esriLicenseAvailable)
{
if (m_AoInitializeClass.Initialize(code) == esriLicenseStatus.esriLicenseCheckedOut)
{
m_AoInitializeClass.InitializedProduct();
//TraceHandler.AddDebugMessage("check out successed : " + aoInit.GetLicenseProductName(code));
return(true);
}
//TraceHandler.AddErrorMessage("!!!check out error : " + aoInit.GetLicenseProductName(code));
}
}
catch (Exception ex)
{
LOG.Error(ex);
//TraceHandler.AddException(ex);
}
return(false);
}
/// <summary>
/// Attempts to checkout a license for the specified ESRI product and returns true if successful.
/// </summary>
public bool GetArcGISLicense(esriLicenseProductCode prodCode)
{
//Create a new AoInitialize object
try
{
_AoInitialize = new AoInitializeClass();
}//The initialization object
catch
{
_log.Warn("Warning: Unable to initialize Arc Objects. License cannot be checked out.");
return false;
}
if (_AoInitialize == null)
{
_log.Warn("Warning: Unable to initialize Arc Objects. License cannot be checked out.");
return false;
}
//Determine if the product is available
esriLicenseStatus licenseStatus = (esriLicenseStatus)_AoInitialize.IsProductCodeAvailable(prodCode);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = (esriLicenseStatus)_AoInitialize.Initialize(prodCode);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
_log.Warn("Warning: The license checkout for " + prodCode.ToString() + " failed!");
return false;
}
}
else
{
_log.Warn("Warning: The ArcGIS product " + prodCode.ToString() + " is unavailable!");
return false;
}
return true;
}
static void Main()
{
if (!RuntimeManager.Bind(ProductCode.EngineOrDesktop))
{
MessageBox.Show("Unable to bind ArcGis Runtime ,Application will be shut down");
return;
}
GdalConfiguration.ConfigureGdal();
AoInitialize aoi = new AoInitializeClass();
esriLicenseProductCode productcode = esriLicenseProductCode.esriLicenseProductCodeEngine;
if (aoi.IsProductCodeAvailable(productcode) == esriLicenseStatus.esriLicenseAvailable)
{
aoi.Initialize(productcode);
}
//ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Engine);
//ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
public bool InitialLicensesCode(esriLicenseProductCode[] esriProductCodes,params esriLicenseExtensionCode[] esriExtensionCodes)
{
if(productCodeList==null)
productCodeList = new List<int>();//将产品码添加到list集合中，Cache product codes by enum int so can be sorted without custom sorter
foreach (esriLicenseProductCode item in esriProductCodes)
{
int codeNum = Convert.ToInt32(item);
if (!productCodeList.Contains(codeNum))
{
productCodeList.Add(codeNum);
}
}
AddExtensions(esriExtensionCodes);
//验证runtime绑定
if (RuntimeManager.ActiveRuntime == null)
{
EventHandler eventHandler = ResolveBindingEvent;
if (eventHandler != null)
{
eventHandler(this,new EventArgs());
}
}
return InitializeProduct();
}
static int Main(string[] args)
{
#if ARCGIS_10_0
const esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeArcInfo;
#else
const esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeAdvanced;
#endif
if (!LicenseInitializer.InitializeApplication(new [] { productCode },
new esriLicenseExtensionCode[] { }))
{
Console.WriteLine(LicenseInitializer.LicenseMessage());
Console.WriteLine("This application could not initialize with the correct ArcGIS license and will shutdown.");
LicenseInitializer.ShutdownApplication();
return(2);
}
//args = new[] { "Single", @"C:\tmp\Locations.lyr", @"dbclient=SQLServer;serverinstance=INPAKRO39088\SQL2008R2;database=Animal_Movement;authentication_mode=OSA", "SELECT * FROM Locations" };
//args = new[] { "Multiple", @"C:\tmp\LACL_wolf_1120.lyr", @"dbclient=SQLServer;serverinstance=INPAKROMS53AIS;database=Animal_Movement;authentication_mode=OSA", "ProjectId = 'LACL_Wolf' AND AnimalId = 'LC1120'" };
//args = new[] { "Prebuilt", @"C:\tmp\Template.lyr", @"C:\tmp\Locations.lyr", @"dbclient=SQLServer;serverinstance=INPAKRO39088\SQL2008R2;database=Animal_Movement;authentication_mode=OSA", "ProjectId = 'LACL_Sheep' AND AnimalId = '0602'" };
if (args.Length < 2)
{
Console.WriteLine("Insufficient arguments. Usage: QueryLayerBuilder Style Style_parameters");
LicenseInitializer.ShutdownApplication();
return(3);
}
var style = args[0].ToLower()[0];
switch (style)
{
case 's':
if (args.Length < 4)
{
Console.WriteLine("Insufficient arguments. Usage: QueryLayerBuilder Single \"Layer Name\" \"path\\to\\new\\file.lyr\" \"Connection string\" \"SQL SELECT Query\"");
LicenseInitializer.ShutdownApplication();
return(3);
}
SingleQueryLayer(args[1], args[2], args[3]);
break;
case 'm':
if (args.Length < 3)
{
Console.WriteLine("Insufficient arguments. Usage: QueryLayerBuilder Multiple \"path\\to\\new\\file.lyr\" [\"Connection string\"] [\"SQL predicate\"]");
LicenseInitializer.ShutdownApplication();
return(3);
}
MultipleQueryLayer(args[1], args[2], args.Length > 3 ? args[3] : "");
break;
case 'p': //Prebuilt
if (args.Length < 3)
{
Console.WriteLine("Insufficient arguments. Usage: QueryLayerBuilder Prebuilt \"path\\to\\template.lyr\" \"path\\to\\new\\file.lyr\" [\"Connection string\"] [\"SQL predicate\"]");
LicenseInitializer.ShutdownApplication();
return(3);
}
//PrebuiltQueryLayer(args[1], args[2], (args.Length > 3 ? args[3] : ""), (args.Length > 4 ? args[4] : ""));
//break;
Console.WriteLine("QueryLayerBuilder Prebuilt Not implemented yet");
LicenseInitializer.ShutdownApplication();
return(3);
default:
//throw new ArgumentOutOfRangeException("args", args[0], "Style is not recognized.");
Console.WriteLine("Style parameter `" + args[0] + "' is not recognized.");
LicenseInitializer.ShutdownApplication();
return(3);
}
LicenseInitializer.ShutdownApplication();
return(0);
}
/// <summary>
/// Attempts to checkout the license for the specific ESRI <paramref name="licensedProduct" />.
/// </summary>
/// <param name="licensedProduct">The licensed product.</param>
/// <param name="licensedExtension">The licensed extension.</param>
/// <returns>
/// Returns a <see cref="Boolean" /> representing <c>true</c> when the initialization is successful; otherwise
/// <c>false</c>.
/// </returns>
public bool Initialize(esriLicenseProductCode licensedProduct, params esriLicenseExtensionCode[] licensedExtension)
{
return(_EsriRuntime.Initialize(new[] { licensedProduct }, licensedExtension));
}
/// <summary>
/// Attempts to checkout the license for the specific ArcFM <paramref name="mmLicensedProduct" /> and ESRI
/// <paramref name="esriLicensedProduct" />.
/// </summary>
/// <param name="esriLicensedProduct">The ArFM product code.</param>
/// <param name="mmLicensedProduct">The mm licensed product.</param>
/// <returns>
/// Returns a <see cref="Boolean" /> representing <c>true</c> when the initialization is successful; otherwise
/// <c>false</c>.
/// </returns>
public bool Initialize(esriLicenseProductCode esriLicensedProduct, mmLicensedProductCode mmLicensedProduct)
{
return(this.Initialize(esriLicensedProduct) && this.Initialize(mmLicensedProduct));
}
/// <summary>
/// Initialize application license
/// </summary>
/// <param name="productCodes">Products codes</param>
/// <param name="extensionLics">Extensions codes.</param>
public bool InitializeApplication(esriLicenseProductCode[] productCodes, esriLicenseExtensionCode[] extensionLics)
{
if (!RuntimeManager.Bind(ProductCode.EngineOrDesktop))
{
return false;
}
_aoInit = new AoInitializeClass();
// Cache product codes by enum int so can be sorted without custom sorter
_requestedProducts = new List<int>();
foreach (var requestCodeNum in productCodes.Select(code => Convert.ToInt32(code)).Where(requestCodeNum => !_requestedProducts.Contains(requestCodeNum)))
{
_requestedProducts.Add(requestCodeNum);
}
AddExtensions(extensionLics);
return Initialize();
}
/// <summary>
/// Checks out an ArcGIS Desktop license
/// </summary>
/// <returns>bool</returns>
public bool CheckoutLicense()
{
bool isBound = ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
if (!isBound)
{
Console.WriteLine("Could not bind to ArcGIS Desktop:");
return(isBound);
}
IAoInitialize ipAo = new AoInitializeClass();
if (ipAo == null)
{
ipAo = new AoInitializeClass();
}
esriLicenseStatus eStatus = esriLicenseStatus.esriLicenseNotLicensed;
esriLicenseProductCode eProductCode = esriLicenseProductCode.esriLicenseProductCodeStandard;
if ((eStatus = ipAo.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeStandard)) == esriLicenseStatus.esriLicenseAvailable)
{
eStatus = ipAo.Initialize(esriLicenseProductCode.esriLicenseProductCodeStandard);
eProductCode = esriLicenseProductCode.esriLicenseProductCodeStandard;
}
else if ((eStatus = ipAo.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeAdvanced)) == esriLicenseStatus.esriLicenseAvailable)
{
eStatus = ipAo.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
eProductCode = esriLicenseProductCode.esriLicenseProductCodeAdvanced;
}
else
{
Console.WriteLine("No ArcGIS Licenses available");
return(false);
}
if (eStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
Console.WriteLine("Unable to check out ArcGIS license.");
return(false);
}
if (!ipAo.IsExtensionCheckedOut(esriLicenseExtensionCode.esriLicenseExtensionCodeWorkflowManager))
{
eStatus = ipAo.IsExtensionCodeAvailable(eProductCode, esriLicenseExtensionCode.esriLicenseExtensionCodeWorkflowManager);
if (eStatus != esriLicenseStatus.esriLicenseAvailable)
{
Console.WriteLine("No JTX licenses available.");
return(false);
}
else
{
eStatus = ipAo.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeWorkflowManager);
if (eStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
Console.WriteLine("Unable to check out JTX license.");
return(false);
}
}
}
Console.WriteLine("Successfully checked out licenses.");
return(true);
}
public esriLicenseStatus Initialize(esriLicenseProductCode code)
{
return esriLicenseStatus.esriLicenseCheckedOut;
}
public esriLicenseStatus IsExtensionCodeAvailable(esriLicenseProductCode p, esriLicenseExtensionCode e)
{
return esriLicenseStatus.esriLicenseCheckedIn;
}
public esriLicenseStatus IsProductCodeAvailable(esriLicenseProductCode code)
{
return esriLicenseStatus.esriLicenseAvailable;
}
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 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 bool CheckOutLicense(esriLicenseProductCode currentProduct)
{
bool success = true;
if (extensionCodeList.Count > 0 && currentProduct != 0)
{
foreach (esriLicenseExtensionCode item in extensionCodeList)
{
esriLicenseStatus licenseStatus = aoInitialize.IsExtensionCodeAvailable(currentProduct, item);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
if (!aoInitialize.IsExtensionCheckedOut(item))
{
licenseStatus = aoInitialize.CheckOutExtension(item);
}
}
success = (success && licenseStatus == esriLicenseStatus.esriLicenseCheckedOut);//如果success是false，那么一直都是false！
if (dic_ExtensionStatus.ContainsKey(item))//将扩展与扩展状态添加到字典中去
{
dic_ExtensionStatus[item] = licenseStatus;
}
else
{
dic_ExtensionStatus.Add(item, licenseStatus);
}
}
extensionCodeList.Clear();//清空扩展列表
}
return success;
}
public string GetLicenseProductName (esriLicenseProductCode code)
{
return string.Empty;
}
private esriLicenseStatus CheckOutLicenses()
{
var licenseStatus = esriLicenseStatus.esriLicenseNotInitialized;
//Determine if the product is available
foreach (esriLicenseProductCode productCode in _productsCodes)
{
licenseStatus = _aoInitialize.IsProductCodeAvailable(productCode);
if (licenseStatus != esriLicenseStatus.esriLicenseAvailable)
{
continue;
}
// NOTE: in case the license expires in less than 15 days and the registry key
// HKEY_LOCAL_MACHINE\Software\ESRI\License does not have a string value
// with the name TIMEOUTWARNING and the value FALSE
// a message box will pop up here. This is a problem if running as scheduled
// task - make sure this value exists and is set to false on all servers!
_msg.DebugFormat("Initializing license: {0}", productCode);
licenseStatus = _aoInitialize.Initialize(productCode);
if (licenseStatus == esriLicenseStatus.esriLicenseCheckedOut)
{
_initProduct = productCode;
break;
}
}
if (_extensionsCodes != null)
{
//Checkout the extensions - only when product is initialized
if (licenseStatus == esriLicenseStatus.esriLicenseCheckedOut)
{
var checkedOutExtensions =
new List <esriLicenseExtensionCode>(_extensionsCodes.Length);
foreach (esriLicenseExtensionCode extLicense in _extensionsCodes)
{
//Determine if the extensions are available - some may not be available depending on the product initialized
//If so, initialization fails...
licenseStatus =
_aoInitialize.IsExtensionCodeAvailable(_initProduct, extLicense);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
_msg.DebugFormat("Checking out extension: {0}", extLicense);
licenseStatus = _aoInitialize.CheckOutExtension(extLicense);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut &&
licenseStatus != esriLicenseStatus.esriLicenseAlreadyInitialized)
{
break;
}
//Add to license initialized list
checkedOutExtensions.Add(extLicense);
}
else
{
break; //Exit when failed to check out any extension
}
}
if (checkedOutExtensions.Count > 0)
{
_initializedExtensions = checkedOutExtensions.ToList();
}
}
}
return(licenseStatus);
}
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;
}
/// <summary>
/// Checkout licenses
/// </summary>
/// <param name="currentProduct">producto code</param>
private bool CheckOutLicenses(esriLicenseProductCode currentProduct)
{
var allSuccessful = true;
// Request extensions
if (_requestedExtensions != null && currentProduct != 0)
{
foreach (var ext in _requestedExtensions)
{
var licenseStatus = _aoInit.IsExtensionCodeAvailable(currentProduct, ext);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = _aoInit.CheckOutExtension(ext);
}
allSuccessful = allSuccessful && licenseStatus == esriLicenseStatus.esriLicenseCheckedOut;
if (_extensionStatus.ContainsKey(ext))
{
_extensionStatus[ext] = licenseStatus;
}
else
{
_extensionStatus.Add(ext, licenseStatus);
}
}
_requestedExtensions.Clear();
}
return allSuccessful;
}
/// <summary>
/// Initilize
/// </summary>
private bool Initialize()
{
if (RuntimeManager.ActiveRuntime == null)
{
return false;
}
if (_requestedProducts == null || _requestedProducts.Count == 0)
{
return false;
}
var currentProduct = new esriLicenseProductCode();
var productInitialized = false;
_requestedProducts.Sort();
if (!InitializeLowerProductFirst)
{
_requestedProducts.Reverse();
}
foreach (var prodNumber in _requestedProducts)
{
var prod = (esriLicenseProductCode)System.Enum.ToObject(typeof(esriLicenseProductCode), prodNumber);
var status = _aoInit.IsProductCodeAvailable(prod);
if (status == esriLicenseStatus.esriLicenseAvailable)
{
status = _aoInit.Initialize(prod);
if (status == esriLicenseStatus.esriLicenseAlreadyInitialized || status == esriLicenseStatus.esriLicenseCheckedOut)
{
productInitialized = true;
currentProduct = _aoInit.InitializedProduct();
}
}
_productStatus.Add(prod, status);
if (productInitialized)
{
break;
}
}
_hasInitializeProduct = productInitialized;
_requestedProducts.Clear();
// No product is initialized after trying all requested licenses, quit
return productInitialized && CheckOutLicenses(currentProduct);
}
public ArcGISTestHelper()
{
this.ESRILicenseProductCode = esriLicenseProductCode.esriLicenseProductCodeArcView;
Initialize();
}
