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}");
}
}
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 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);
}
}
}
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 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);
}
public esriLicenseStatus CheckoutExtension(esriLicenseExtensionCode extensionCode)
{
esriLicenseStatus status = _aoInitialize.CheckOutExtension(extensionCode);
if (status == esriLicenseStatus.esriLicenseCheckedOut)
{
if (_initializedExtensions == null)
{
_initializedExtensions = new List <esriLicenseExtensionCode> {
extensionCode
};
}
else if (!_initializedExtensions.Contains(extensionCode))
{
_initializedExtensions.Add(extensionCode);
}
}
return(status);
}
public ArcEngineLicense(byte licenseType, byte extensionCode)
{
lock (_mutexLocker)
{
RegisterLicenseService(licenseType);
if (extensionCode > 0)
{
m_extensionCode = extensionCode;
m_pAoInit.CheckOutExtension((esriLicenseExtensionCode)m_extensionCode);
}
}
}
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 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;
}
