/// <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;
}
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);
}
public void ShutdownApplication()
{
if (m_AoInitialize == null)
{
return;
}
//关闭 AoInitilaize对象
m_AoInitialize.Shutdown();
m_AoInitialize = null;
}
/// <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);
}
public SplineEngine()
{
//Model Info
Id = "Spline Interpolation";
Caption = "Spline Interpolation";
Description = "Performs a spline interpolation to create a surface raster";
_simulationStart = new Time(new DateTime(2005, 1, 1, 0, 0, 0));
_simulationEnd = new Time(new DateTime(2005, 1, 2, 0, 0, 0));
_currentTime = new Time(_simulationStart);
_timeStepLengthInSeconds = 3600 * 24;
_timeStepLengthInDays = _timeStepLengthInSeconds / (24.0 * 3600.0);
_outputFiles = new Dictionary <string, bool>();
numProcessed = 0;
license = new AoInitializeClass();
}
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 FillEngine()
{
//model ID
this.Id = "Raster Fill";
//Component GUI Caption
this.Caption = "Raster Fill";
//model description
this.Description = "Fills sinks in a raster grid";
_simulationStart = new Time(new DateTime(2005, 1, 1, 0, 0, 0));
_simulationEnd = new Time(new DateTime(2005, 1, 2, 0, 0, 0));
_currentTime = new Time(_simulationStart);
_timeStepLengthInSeconds = 3600 * 24; //one day
_timeStepLengthInDays = _timeStepLengthInSeconds / (24.0 * 3600.0);
numProcessed = 0;
license = new AoInitializeClass();
}
public FaccEngine()
{
//model ID
this.Id = "Flow Accumulation";
//Component GUI Caption
this.Caption = "Flow Accumulation";
//model description
this.Description = "Calculates the Flow Accumulation for each pixel on a surface raster";
_simulationStart = new Time(new DateTime(2005, 1, 1, 0, 0, 0));
_simulationEnd = new Time(new DateTime(2005, 1, 2, 0, 0, 0));
_currentTime = new Time(_simulationStart);
_timeStepLengthInSeconds = 3600 * 24; //one day
_timeStepLengthInDays = _timeStepLengthInSeconds / (24.0 * 3600.0);
numProcessed = 0;
license = new AoInitializeClass();
}
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 bool InitializeApplication(
[NotNull] esriLicenseProductCode[] productCodes,
[NotNull] esriLicenseExtensionCode[] extensionLicenseCodes)
{
try
{
TryBindProduct(productCodes);
}
catch (Exception ex)
{
_msg.Debug("Exception while binding ArcGIS 10 product.", ex);
}
if (_aoInitialize == null)
{
try
{
// If the next line fails with error code -2147221164: make sure that exe's are compiled for x86
// Otherwise on 64bit systems this error occurs.
_aoInitialize = new AoInitializeClass();
}
catch (Exception e)
{
_msg.Debug("Error initializing ArcObjects", e);
_msg.Warn("Unable to initialize ArcGIS. This application cannot run! " +
"Please check that ArcGIS (Desktop, Engine or Server) is installed.");
return(false);
}
}
//Initialize the application
_productsCodes = productCodes;
_extensionsCodes = extensionLicenseCodes;
esriLicenseStatus licenseStatus = CheckOutLicenses();
if (licenseStatus != esriLicenseStatus.esriLicenseCheckedOut)
{
_msg.WarnFormat("ESRI License Initializer: {0}", LicenseMessage(licenseStatus));
return(false);
}
return(true);
}
public void Dispose()
{
lock (_mutexLocker)
{
if (m_pAoInit == null)
{
return;
}
if (m_extensionCode > 0 &&
m_pAoInit.IsExtensionCheckedOut((esriLicenseExtensionCode)m_extensionCode))
{
m_pAoInit.CheckInExtension((esriLicenseExtensionCode)m_extensionCode);
}
UnRegisterLicenseService();
m_pAoInit = null;
}
}
private void RegisterLicenseService(byte licenseType)
{
bool bindSuccess = (licenseType == 1) ? RuntimeManager.Bind(ProductCode.Engine) :
((licenseType == 2) ? RuntimeManager.Bind(ProductCode.Desktop) :
RuntimeManager.Bind(ProductCode.EngineOrDesktop));
if (bindSuccess == false)
{
throw new Exception("不能绑定到ArcGIS产品！");
}
if (m_pAoInit != null)
{
if (m_extensionCode > 0 &&
m_pAoInit.IsExtensionCheckedOut((esriLicenseExtensionCode)m_extensionCode))
{
m_pAoInit.CheckInExtension((esriLicenseExtensionCode)m_extensionCode);
}
UnRegisterLicenseService();
m_pAoInit = null;
}
m_pAoInit = new AoInitializeClass();
bool enabled;
// ArcGIS 10以下版本不区分ArcEngine或Desktop，10以上区分产品
enabled = (RuntimeManager.ActiveRuntime.Product == ProductCode.Engine);
if (enabled && (InitializeProduct(esriLicenseProductCode.esriLicenseProductCodeAdvanced) ||
InitializeProduct(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB)))
{
return;
}
enabled = (RuntimeManager.ActiveRuntime.Product == ProductCode.Desktop);
if (enabled && (InitializeProduct(esriLicenseProductCode.esriLicenseProductCodeAdvanced) ||
InitializeProduct(esriLicenseProductCode.esriLicenseProductCodeStandard) ||
InitializeProduct(esriLicenseProductCode.esriLicenseProductCodeBasic)))
{
return;
}
throw new System.Exception("ArcGIS License Cannot Checkout");
}
public void ShutdownApplication()
{
if (m_AoInitialize == null) return;
//Checkin the extensions
if (m_initExts != null)
{
foreach (esriLicenseExtensionCode extLicense in m_initExts)
{
if (m_AoInitialize.CheckInExtension(extLicense) != esriLicenseStatus.esriLicenseCheckedIn)
{
//Silent check in error
//System.Diagnostic.Trace.WriteLine(LicenseMessage(licenseStatus), "ESRI License Initializer")
}
}
}
//Shut down the AoInitialize object
m_AoInitialize.Shutdown();
m_AoInitialize = null;
}
} // 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>
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);
}
public void ShutdownApplication()
{
if (m_AoInitialize == null)
{
return;
}
//Checkin the extensions
if (m_initExts != null)
{
foreach (esriLicenseExtensionCode extLicense in m_initExts)
{
if (m_AoInitialize.CheckInExtension(extLicense) != esriLicenseStatus.esriLicenseCheckedIn)
{
//Silent check in error
//System.Diagnostic.Trace.WriteLine(LicenseMessage(licenseStatus), "ESRI License Initializer")
}
}
}
//Shut down the AoInitialize object
m_AoInitialize.Shutdown();
m_AoInitialize = null;
}
/// <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 static void ReturnESRILicense(IAoInitialize pESRILicense)
{
if (pESRILicense != null)
{
pESRILicense.Shutdown(); // RELEASE THE LICENSE
Marshal.ReleaseComObject(pESRILicense);
}
}
/// <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();
}
public AdvAELicenseClass()
{
RuntimeManager.Bind(ProductCode.EngineOrDesktop);
m_AoInitializeClass = new AoInitializeClass();
}
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 static void old_acctor_mc()
{
m_pAoInitialize = null;
}
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);
}
