/// <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);
}
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 static void InitializeLicensing(IAoInitialize aoInit)
{
// Check out the lowest available license level.
var licenseLevels = new List <esriLicenseProductCode>()
{
esriLicenseProductCode.esriLicenseProductCodeBasic,
esriLicenseProductCode.esriLicenseProductCodeEngine,
esriLicenseProductCode.esriLicenseProductCodeStandard,
esriLicenseProductCode.esriLicenseProductCodeAdvanced,
esriLicenseProductCode.esriLicenseProductCodeArcServer
};
var licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
foreach (var licenseLevel in licenseLevels)
{
licenseStatus = aoInit.Initialize(licenseLevel);
if (licenseStatus == esriLicenseStatus.esriLicenseCheckedOut || licenseStatus == esriLicenseStatus.esriLicenseAlreadyInitialized)
{
break;
}
}
if (licenseStatus != esriLicenseStatus.esriLicenseAlreadyInitialized && licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
throw new ArcGISLicensingException($"Product license initialization failed. License status: {licenseStatus}");
}
licenseStatus = aoInit.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork);
if (licenseStatus != esriLicenseStatus.esriLicenseAlreadyInitialized && licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
throw new ArcGISLicensingException($"Network extension license initialization failed. License status: {licenseStatus}");
}
}
public void SetUp()
{
license = new AoInitializeClass();
license.Initialize(esriLicenseProductCode.esriLicenseProductCodeArcEditor);
_dataDirectory = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
}
private static void getLicense()
{
if (!ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop))
{
throw new Exception("Could not set version. ");
}
m_License = new AoInitializeClass();
m_License.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
}
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 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);
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));
}
/// <summary>
/// Create an instance of the test class.
/// </summary>
/// <remarks>Constructor contains necessary set up logic, including initialisation of esri license and opening test feature classes</remarks>
public EsriToGeoJsonTest()
{
//initialise an esri license
ESRI.ArcGIS.RuntimeManager.BindLicense(ESRI.ArcGIS.ProductCode.Desktop);
if (!ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop))
{
throw new ApplicationException("Failed to initialise ArcGIS License");
}
_license = new AoInitialize();
_license.Initialize(esriLicenseProductCode.esriLicenseProductCodeArcView);
}
private esriLicenseStatus CheckOutLicenses(esriLicenseProductCode productCode)
{
esriLicenseStatus licenseStatus;
//是否产品是可能的
licenseStatus = m_AoInitialize.IsProductCodeAvailable(productCode);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
//用相应的许可文件进行初始化
licenseStatus = m_AoInitialize.Initialize(productCode);
}
return(licenseStatus);
}
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);
}
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 _IdentifySDE()
{
try
{
if (!ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop))
{
System.Environment.Exit(0);
}
m_AoInitialize = new ESRI.ArcGIS.esriSystem.AoInitialize();
m_AoInitialize.Initialize(ESRI.ArcGIS.esriSystem.esriLicenseProductCode.esriLicenseProductCodeAdvanced);
}
catch
{
return(false);
}
return(true);
}
public static void MyTestInitialize(TestContext testContext)
{
// 初始化ArcObjects权限
#region Licensing
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
aoInitialize = new AoInitializeClass();
licenseStatus = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
Console.WriteLine("Unable to check-out an ArcInfo license, error code is {0}", licenseStatus);
return;
}
#endregion
// 创建测试结果文件夹
System.IO.Directory.CreateDirectory(m_testResultFolder);
}
public static bool StartUp()
{
try
{
if (aoinitialize == null)
{
Console.WriteLine("没有安装ARCEngine，系统无法进行");
return(false);
}
ESRI.ArcGIS.esriSystem.esriLicenseStatus licensesStatus = (ESRI.ArcGIS.esriSystem.esriLicenseStatus)aoinitialize.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
if (licensesStatus == esriLicenseStatus.esriLicenseAvailable)
{
licensesStatus = (esriLicenseStatus)aoinitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
if (licensesStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
Console.WriteLine("没有ARCEngine中的GDBEdit许可！");
return(false);
}
}
else
{
Console.WriteLine("没有ARCEngine中的GDBEdit许可！");
return(false);
}
licensesStatus = aoinitialize.IsExtensionCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeEngine, esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork);
licensesStatus = (ESRI.ArcGIS.esriSystem.esriLicenseStatus)aoinitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork);
if (licensesStatus == esriLicenseStatus.esriLicenseCheckedOut)
{
}
else
{
Console.WriteLine("没有ARCEngine中的NetWork许可！");
return(false);
}
}
catch (Exception ex)
{
Console.WriteLine("ArcEngine的许可错误" + ex.Message);
return(false);
}
return(true);
}
//签出产品许可
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);
}
/// <summary>
///
/// </summary>
public LicenseInit()
{
esriLicenseProductCode esriProductCode = esriLicenseProductCode.esriLicenseProductCodeArcServer;
if (RuntimeManager.Bind(ProductCode.Server))
{
isInitialized = true;
esriProductCode = esriLicenseProductCode.esriLicenseProductCodeArcServer;
}
else if (RuntimeManager.Bind(ProductCode.Desktop))
{
esriProductCode = esriLicenseProductCode.esriLicenseProductCodeStandard;
isInitialized = true;
}
else
{
throw new Exception("ESRI license not available");
}
I_LicenseInitializer = new AoInitialize();
I_LicenseInitializer.Initialize(esriProductCode);
}
/// <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;
}
public override void Initialize(IArgument[] arguments)
{
//set component to run in loop mode
this.CascadingUpdateCallsDisabled = true;
Status = LinkableComponentStatus.Initializing;
//read arguments
foreach (IArgument entry in arguments)
{
if (entry.Id == "ElevationSurface")
{
_Inpath = Path.GetFullPath(entry.Value.ToString());
}
else if (entry.Id == "OutputFile")
{
_outpath = Path.GetFullPath(entry.Value.ToString());
}
}
// -- Time settings for input and output exchange items --
ITime timeHorizon = new Time(StartTime, EndTime);
//Create input element set
Element e = new Element("Elevation Surface");
e.Id = "Elevation Surface";
ElementSet eSet = new ElementSet("Elevation Surface", "Elevation Surface", ElementType.IdBased);
eSet.AddElement(e);
Quantity quantity = new Quantity(new Unit("Raster", 1.0, 0.0, "Raster"), "Elevation Surface", "Elevation Surface");
//add input item
_InputItem = new EngineEInputItem("ElevationSurface", quantity, eSet, this);
//_InputItem.StoreValuesInExchangeItem = true;
_InputItem.SetTimeHorizon(timeHorizon);
this.EngineInputItems.Add(_InputItem);
_InputItem.SetSingleTime(StartTime);
//add input exchange item to input item list
_inputs.Add(_InputItem);
//create output element set
e = new Element("Filled Surface");
e.Id = "Filled Surface";
eSet = new ElementSet("Filled Surface", "Filled Surface", ElementType.IdBased);
eSet.AddElement(e);
quantity = new Quantity(new Unit("Raster", 1.0, 0.0, "Raster"), "Filled Surface", "Filled Surface");
//add output item
_OutputItem = new EngineEOutputItem("Filled Surface", quantity, eSet, this);
_OutputItem.SetSingleTime(StartTime);
//_OutputItem.StoreValuesInExchangeItem = true;
_OutputItem.SetTimeHorizon(timeHorizon);
this.EngineOutputItems.Add(_OutputItem);
//add output exchange item to output item list
_outputs.Add(_OutputItem);
//initialize geoprocessing objects
GP = new Geoprocessor();
GP.OverwriteOutput = true;
//checkout spatial analyst license
esriLicenseStatus LicenseStatus = esriLicenseStatus.esriLicenseUnavailable;
LicenseStatus = license.Initialize(esriLicenseProductCode.esriLicenseProductCodeArcInfo);
LicenseStatus = license.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst);
Status = LinkableComponentStatus.Initialized;
}
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 static void getLicense()
{
if (!ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop))
throw new Exception("Could not set version. ");
m_License = new AoInitializeClass();
m_License.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
}
private bool Initialize()
{
//Version 10 check
//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();
//version 9.3 check
//Try to initialize a product
ILicenseInformation licInfo = (ILicenseInformation)m_AoInit;
// licInfo is not used??
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);
}
