/// <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();
}
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));
}
public static void MyClassInitialize(TestContext testContext)
{
bool blnBoundToRuntime = ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
Assert.IsTrue(blnBoundToRuntime, "Not bound to runtime");
IAoInitialize aoInitialize = new AoInitializeClass();
aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeBasic);
}
public imageAnalysisUtil()
{
gp.OverwriteOutput = true;
IAoInitialize a = new AoInitializeClass();
if (!a.IsExtensionCheckedOut(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst))
{
weCheckedOutSpa = true;
a.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst);
}
}
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 static void InitializeEngineLicense()
{
AoInitialize aoInitialize = new AoInitializeClass();
const esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeArcInfo;
if (aoInitialize.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoInitialize.Initialize(productCode);
}
}
static void Main()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
ESRI.ArcGIS.RuntimeManager.BindLicense(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
IAoInitialize pAoInit = new AoInitializeClass();;
pAoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
public imageAnalysisUtil()
{
gp.OverwriteOutput = true;
IAoInitialize a = new AoInitializeClass();
if (!a.IsExtensionCheckedOut(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst))
{
weCheckedOutSpa = true;
a.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst);
}
}
private void InitializeEngineLicense()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
AoInitialize aoi = new AoInitializeClass ();
//more license choices could be included here
esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeEngine;
if (aoi.IsProductCodeAvailable (productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoi.Initialize (productCode);
}
}
public MainForm_GM()
{
RuntimeManager.Bind(ProductCode.EngineOrDesktop);
IAoInitialize aoini = new AoInitializeClass();
var licenseStatus = aoini.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeStandard);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = aoini.Initialize(esriLicenseProductCode.esriLicenseProductCodeStandard);
}
InitializeComponent();
}
private static void InitializeEngineLicense()
{
AoInitialize aoInitialize = new AoInitializeClass();
const esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeArcInfo;
if (aoInitialize.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoInitialize.Initialize(productCode);
}
}
public void InitTest()
{
RuntimeManager.Bind(ProductCode.Desktop);
AoInitialize aoInit = new AoInitializeClass();
aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
syriaLocalRoadsLargeArray =
File.ReadAllLines(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + SyriaLocalRoadsLargeFile);
}
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);
}
}
/// <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);
}
private void InitializeEngineLicense()
{
AoInitialize aoi = new AoInitializeClass();
//more license choices could be included here
esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeArcEditor;
if (aoi.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoi.Initialize(productCode);
}
}
public void GISShutdown()
{
try
{
IAoInitialize aoInit = new AoInitializeClass();
aoInit.Shutdown();
}
catch (Exception ex)
{
throw new Exception(string.Format("关闭ESRI许可证时发生错误：{0}", ex.Message));
}
}
public MainForm_GM()
{
RuntimeManager.Bind(ProductCode.EngineOrDesktop);
IAoInitialize aoini = new AoInitializeClass();
var licenseStatus = aoini.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeStandard);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = aoini.Initialize(esriLicenseProductCode.esriLicenseProductCodeStandard);
}
InitializeComponent();
}
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);
}
}
static void Main()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
ESRI.ArcGIS.RuntimeManager.BindLicense(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
IAoInitialize aoInit = new AoInitializeClass();
aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeArcServer);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new FrmFeatureStandard());
}
internal static void InitializeEngineLicense()
{
RuntimeManager.Bind(ProductCode.EngineOrDesktop);
AoInitialize aoi = new AoInitializeClass();
//more license choices could be included here
const esriLicenseProductCode productCode = esriLicenseProductCode.esriLicenseProductCodeEngine;
if (aoi.IsProductCodeAvailable(productCode) == esriLicenseStatus.esriLicenseAvailable)
{
aoi.Initialize(productCode);
}
}
private void InitializeEngineLicense()
{
AoInitialize aoi = new AoInitializeClass();
//Additional license choices can be included here.
esriLicenseProductCode productCode =
esriLicenseProductCode.esriLicenseProductCodeArcInfo;
if (aoi.IsProductCodeAvailable(productCode) ==
esriLicenseStatus.esriLicenseAvailable)
{
aoi.Initialize(productCode);
}
}
public MainForm_OP()
{
RuntimeManager.Bind(ProductCode.EngineOrDesktop);
IAoInitialize aoini = new AoInitializeClass();
var licenseStatus = aoini.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeStandard);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = aoini.Initialize(esriLicenseProductCode.esriLicenseProductCodeStandard);
}
//LicenseInitializer license = new LicenseInitializer();
//bool islicense=license.InitializeApplication();
InitializeComponent();
}
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);
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
ESRI.ArcGIS.RuntimeManager.BindLicense(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
IAoInitialize m_AoInitialize = new AoInitializeClass();
m_AoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngine);
BonusSkins.Register();
SkinManager.EnableFormSkins();
UserLookAndFeel.Default.SetSkinStyle("DevExpress Style");
Application.Run(new Form1());
}
public MainForm_OP()
{
RuntimeManager.Bind(ProductCode.EngineOrDesktop);
IAoInitialize aoini = new AoInitializeClass();
var licenseStatus = aoini.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeStandard);
if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)
{
licenseStatus = aoini.Initialize(esriLicenseProductCode.esriLicenseProductCodeStandard);
}
//LicenseInitializer license = new LicenseInitializer();
//bool islicense=license.InitializeApplication();
InitializeComponent();
}
static void Main()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
ESRI.ArcGIS.RuntimeManager.BindLicense(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
IAoInitialize aoInit = new AoInitializeClass();
aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeArcServer);
//IAoInitialize aoInit = new AoInitializeClass();
//aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngine);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
//KYKJ.MIS.Initial.InitialConfig.Execute();
Application.Run(new FrmSDEConnect());
}
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;
}
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());
}
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();
}
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());
}
/// <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);
}
}
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);
}
}
// This is used to return whether the function tool is licensed to execute.
public bool IsLicensed()
{
IAoInitialize aoi = new AoInitializeClass();
ILicenseInformation licInfo = (ILicenseInformation)aoi;
string licName = licInfo.GetLicenseProductName(aoi.InitializedProduct());
if (licName == "Advanced")
{
return(true);
}
else
{
return(false);
}
}
// This is used to return whether the function tool is licensed to execute.
public bool IsLicensed()
{
IAoInitialize aoi = new AoInitializeClass();
ILicenseInformation licInfo = (ILicenseInformation)aoi;
var licName = aoi.InitializedProduct();
if (licName == esriLicenseProductCode.esriLicenseProductCodeAdvanced)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// 打开file geodatabase数据库
/// </summary>
/// <param name="strConnString">连接字符串如："D:\\GIS\\GuangYuan\\GuangYuan.gdb"</param>
/// <returns>成功则返回该工作空间；否则返回null</returns>
public static IWorkspace OpenFileGeodatabaseWorkspace(string strConnString)
{
IAoInitialize myIAoInitialize = new AoInitializeClass();
myIAoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngine);
IWorkspaceFactory myIWorkspaceFactory = new FileGDBWorkspaceFactoryClass();
IWorkspace myIWorkspace = null;
try
{
myIWorkspace = myIWorkspaceFactory.OpenFromFile(strConnString, 0);
}
catch
{
}
return(myIWorkspace);
}
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 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;
}
private static void Ensure3dAnalyst()
{
IAoInitialize aoInitialize = new AoInitializeClass();
bool is3dAvailable =
aoInitialize.IsExtensionCheckedOut(
esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst);
if (!is3dAvailable)
{
esriLicenseStatus status =
aoInitialize.CheckOutExtension(
esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst);
_msg.DebugFormat("3D Analyst checkout status: {0}", status);
}
}
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;
}
//签出扩展许可
private static bool CheckOutLicenseExtension(ref AoInitializeClass aoInit, esriLicenseExtensionCode code)
{
try
{
if (aoInit.CheckOutExtension(code) == esriLicenseStatus.esriLicenseCheckedOut)
{
aoInit.GetLicenseExtensionName(code);
//TraceHandler.AddDebugMessage("check out successed :" + aoInit.GetLicenseExtensionName(code));
return(true);
}
//TraceHandler.AddErrorMessage("!!!check out error :" + aoInit.GetLicenseExtensionName(code));
}
catch (Exception ex)
{
Console.WriteLine("初始化错误" + ex.ToString());
}
return(false);
}
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);
}
}
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_aointialize = new AoInitializeClass();
m_aointialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngine);
//ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
}
public static void GetArcGISLicense()
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
IAoInitialize aoInitialize = new AoInitializeClass();
esriLicenseStatus stat;
// checks for Arcview License
stat = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeBasic);
// if not licensed - initialize license
if (stat != esriLicenseStatus.esriLicenseCheckedOut)
{
stat = aoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
}
if (stat != esriLicenseStatus.esriLicenseCheckedOut)
{
Console.WriteLine("Could not get an ArcGIS License");
throw new Exception("Could not get an ArcGIS License");
}
}
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>
/// 初始化产品，只初始化第一个
/// </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);//验证扩展
}
static void Main(string[] args)
{
#region Initialize the license
ESRI.ArcGIS.esriSystem.AoInitialize aoInit = null;
try
{
Console.WriteLine("Obtaining license");
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
aoInit = new AoInitializeClass();
esriLicenseStatus licStatus = aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeStandard);
Console.WriteLine("Ready with license.");
}
catch (Exception exc)
{
// If it fails at this point, shutdown the test and ignore any subsequent errors.
Console.WriteLine(exc.Message);
}
#endregion
//Coordinate system for raster column
IGPCoordinateSystem rSR = new GPCoordinateSystemClass();
rSR.SpatialReference = CreateSpatialReference((int)esriSRProjCSType.esriSRProjCS_World_Mercator);
//Coordinate system for geometry column
IGPSpatialReference gSR = new GPSpatialReferenceClass();
gSR.SpatialReference = CreateSpatialReference((int)esriSRProjCSType.esriSRProjCS_World_Mercator);
//Creates raster catalog
CreateRasterCatalog_GP(rSR, gSR);
//Loads rasters in the given directory to raster catalog
LoadDirToRasterCatalog(outRC, rasterFolder);
System.Console.WriteLine("Loading completed");
System.Console.ReadLine();//waiting user to click a key to finish
//Do not make any call to ArcObjects after license is shut down.
aoInit.Shutdown();
}
static void Main(string[] args)
{
ESRI.ArcGIS.esriSystem.AoInitialize aoInit = null;
try
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
aoInit = new AoInitializeClass();
esriLicenseStatus licStatus = aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeBasic);
Console.WriteLine("License Checkout successful.");
}
catch (Exception exc)
{
// If it fails at this point, shutdown the test and ignore any subsequent errors.
Console.WriteLine(exc.Message);
}
try
{
//Create temporary unmanaged raster catalog and load all rasters
CreateUnmanagedRasterCatalog();
//Open raster catalog
IRasterWorkspaceEx rasterWorkspaceEx = (IRasterWorkspaceEx)OpenRasterPGDBWorkspace(tempPGDBPath);
IRasterCatalog rasterCatalog = rasterWorkspaceEx.OpenRasterCatalog(tempRasterCatalog);
//Mosaic rasters in the raster catalog
Mosaic(rasterCatalog);
}
catch (Exception exc)
{
Console.WriteLine(exc.Message);
}
Console.Write("Please press any key to close the application.");
Console.ReadKey();
//Do not make any call to ArcObjects after ShutDown() call
aoInit.Shutdown();
}
static void Main(string[] args)
{
//If creating a raster dataset in ArcSDE, it will need Standard or Advanced License
ESRI.ArcGIS.esriSystem.AoInitialize aoInit = null;
try
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
aoInit = new AoInitializeClass();
esriLicenseStatus licStatus = aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
Console.WriteLine("License Checkout successful.");
}
catch (Exception exc)
{
// If it fails at this point, shutdown the test and ignore any subsequent errors.
Console.WriteLine(exc.Message);
}
try
{
//Creates an empty raster dataset
//Make sure parameters of the empty raster dataset match our data (number of bands, bit depth, etc.)
CreateRasterDS();
//Loads rasters in the input folder to the new raster dataset
LoadDirToRasterDataset(FGDBPath + "\\" + dsName, rasterFolder);
}
catch (Exception exc)
{
// If it fails at this point, shutdown the test and ignore any subsequent errors.
Console.WriteLine(exc.Message);
}
Console.Write("Please press any key to close the application.");
Console.ReadKey();
//Do not make any call to ArcObjects after ShutDown()
aoInit.Shutdown();
}
public Form1()
{
if (!RuntimeManager.Bind(ProductCode.Desktop))
MessageBox.Show("Could not bind to Desktop");
// Usual engine initialization code follows from here (AoInitialize).
IAoInitialize init = new AoInitializeClass();
esriLicenseStatus licStatus = init.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
if (licStatus == esriLicenseStatus.esriLicenseAvailable)
{
init.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
}
else
{
licStatus = init.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeStandard);
if (licStatus == esriLicenseStatus.esriLicenseAvailable)
{
init.Initialize(esriLicenseProductCode.esriLicenseProductCodeStandard);
}
else
{
licStatus = init.IsProductCodeAvailable(esriLicenseProductCode.esriLicenseProductCodeBasic);
if (licStatus == esriLicenseStatus.esriLicenseAvailable)
{
init.Initialize(esriLicenseProductCode.esriLicenseProductCodeBasic);
}
else
{
MessageBox.Show("No license available for Basic/Standard/Advanced.");
}
}
}
InitializeComponent();
init.Shutdown();
}
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;
}
public void Execute(IArray paramvalues, ITrackCancel TrackCancel, IGPEnvironmentManager envMgr, IGPMessages message)
{
IAoInitialize aoInitialize = new AoInitializeClass();
esriLicenseStatus naStatus = esriLicenseStatus.esriLicenseUnavailable;
IGPUtilities2 gpUtil = null;
IDataset osmDataset = null;
try
{
if (!aoInitialize.IsExtensionCheckedOut(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork))
naStatus = aoInitialize.CheckOutExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork);
gpUtil = new GPUtilitiesClass();
// OSM Dataset Param
IGPParameter osmDatasetParam = paramvalues.get_Element(in_osmFeatureDataset) as IGPParameter;
IDEDataset2 osmDEDataset = gpUtil.UnpackGPValue(osmDatasetParam) as IDEDataset2;
if (osmDEDataset == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), osmDatasetParam.Name));
return;
}
osmDataset = gpUtil.OpenDatasetFromLocation(((IDataElement)osmDEDataset).CatalogPath) as IDataset;
// Network Config File Param
IGPParameter osmNetConfigParam = paramvalues.get_Element(in_NetworkConfigurationFile) as IGPParameter;
IGPValue osmNetConfigFile = gpUtil.UnpackGPValue(osmNetConfigParam) as IGPValue;
if ((osmNetConfigFile == null) || (string.IsNullOrEmpty(osmNetConfigFile.GetAsText())))
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), osmNetConfigParam.Name));
return;
}
// Target Network Dataset Param
IGPParameter ndsParam = paramvalues.get_Element(out_NetworkDataset) as IGPParameter;
IDataElement deNDS = gpUtil.UnpackGPValue(ndsParam) as IDataElement;
if (deNDS == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), ndsParam.Name));
return;
}
// Create Network Dataset
using (NetworkDataset nd = new NetworkDataset(osmNetConfigFile.GetAsText(), osmDataset, deNDS.Name, message, TrackCancel))
{
if (nd.CanCreateNetworkDataset())
nd.CreateNetworkDataset();
}
}
catch (UserCancelException ex)
{
message.AddWarning(ex.Message);
}
catch (Exception ex)
{
message.AddError(120008, ex.Message);
#if DEBUG
message.AddError(120008, ex.StackTrace);
#endif
}
finally
{
if (osmDataset != null)
ComReleaser.ReleaseCOMObject(osmDataset);
if (naStatus == esriLicenseStatus.esriLicenseCheckedOut)
aoInitialize.CheckInExtension(esriLicenseExtensionCode.esriLicenseExtensionCodeNetwork);
if (gpUtil != null)
ComReleaser.ReleaseCOMObject(gpUtil);
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
}
}
/// <summary>
/// initialize license
/// </summary>
/// <returns>status</returns>
private static bool InitLicense()
{
RuntimeManager.Bind(ProductCode.Desktop);
IAoInitialize aoInit = new AoInitializeClass();
esriLicenseStatus status = aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeBasic);
if (status != esriLicenseStatus.esriLicenseCheckedOut)
{
Console.WriteLine("License initialization error");
return false;
}
else
return true;
}
public static void Main(string[] args)
{
ESRI.ArcGIS.esriSystem.AoInitialize aoInit;
#region Initialize Licensing
try
{
Console.WriteLine("Obtaining License");
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
aoInit = new AoInitializeClass();
esriLicenseStatus licStatus = aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
Console.WriteLine("Ready with license");
}
catch (Exception exc)
{
// If it fails at this point, shutdown the test and ignore any subsequent errors.
Console.WriteLine(exc.Message);
return;
}
#endregion
try
{
#region Specify input directory and dataset name
// Specify where to create the File Gdb
string fgdbFolder = @"c:\temp\CustomRasterType";
// Specify the folder to add the data from
string dataSource = @"c:\data\RasterDatasets";
// Specify whether to DELETE the fgdbFolder and create it again (clearing it).
bool clearFGdbFolder = false;
// Specify whether to save the Custom Raster Type generated to an art file.
bool saveToArtFile = true;
// Specify the path and filename to save the custom type.
string customTypeFilePath = @"C:\temp\ThumbnailType.art";
#endregion
#region Raster Type Parameters
string rasterTypeName = @"Thumbnail Raster Dataset";
// Specify the file filter to use to add data (Optional)
string dataSourceFilter = "*.tif";
string rasterTypeProductFilter = @"";
string rasterTypeProductName = @"";
#endregion
TestThumbnailBuilder(rasterTypeName, rasterTypeProductFilter, rasterTypeProductName,
dataSource, dataSourceFilter, fgdbFolder, saveToArtFile, customTypeFilePath, clearFGdbFolder);
#region Shutdown
Console.WriteLine("Press any key...");
Console.ReadKey();
aoInit.Shutdown();
#endregion
}
catch (Exception exc)
{
#region Shutdown
Console.WriteLine("Exception Caught in Main: " + exc.Message);
Console.WriteLine("Failed.");
Console.WriteLine("Shutting down.");
Console.WriteLine("Press any key...");
Console.ReadKey();
// Shutdown License
aoInit.Shutdown();
#endregion
}
}
static void Main()
{
#region Initialize license
ESRI.ArcGIS.esriSystem.AoInitialize aoInit = null;
try
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
aoInit = new AoInitializeClass();
esriLicenseStatus licStatus = aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeBasic);
Console.WriteLine("License Checkout successful.");
}
catch (Exception exc)
{
// If it fails at this point, shutdown the test and ignore any subsequent errors.
Console.WriteLine(exc.Message);
}
#endregion
try
{
//Get the location for data installed with .net sdk
string versionInfo = RuntimeManager.ActiveRuntime.Version;
RegistryKey regKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\ESRI\ArcObjectsSDK" + versionInfo + @"\.NET");
string path = System.Convert.ToString(regKey.GetValue("MainDir"));
string rasterFolder = System.IO.Path.Combine(path, @"Samples\ArcObjectsNET\CustomNodataFilter");
IPixelOperation raster = (IPixelOperation)OpenRasterDataset(rasterFolder, "testimage.tif");
if (raster == null)
{
Console.WriteLine("invalid raster");
return;
}
//create nodatafilter and set properties
CustomNodataFilter.INodataFilter nFilter = new CustomNodataFilter.NodataFilter();
//filter out all values between 0 and 50 as nodata
nFilter.MinNodataValue = 0;
nFilter.MaxNodataValue = 50;
//apply the convolutionfilter to raster
raster.PixelFilter = nFilter;
//set nodata value using the minimum of the nodata range
IRasterProps rasterProps = (IRasterProps)raster;
rasterProps.NoDataValue = 0;
//save the filtered raster to a new raster dataset in TEMP directory
ISaveAs saveAs = (ISaveAs)raster;
//IWorkspace workspace = OpenWorkspace(Environment.GetEnvironmentVariable("TEMP"));
IWorkspace workspace = OpenWorkspace(rasterFolder);
saveAs.SaveAs("nodata.tif", workspace, "TIFF");
Console.WriteLine("Completed");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
//ESRI License Initializer generated code.
//Do not make any call to ArcObjects after ShutDown()
aoInit.Shutdown();
}
// This is used to return whether the function tool is licensed to execute.
public bool IsLicensed()
{
IAoInitialize aoi = new AoInitializeClass();
ILicenseInformation licInfo = (ILicenseInformation)aoi;
string licName = licInfo.GetLicenseProductName(aoi.InitializedProduct());
if (licName == "Advanced")
{
return true;
}
else
return false;
}
static void Main(string[] args)
{
#region Initialize License
ESRI.ArcGIS.esriSystem.AoInitialize aoInit = null;
try
{
Console.WriteLine("Obtaining license");
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Desktop);
aoInit = new AoInitializeClass();
esriLicenseStatus licStatus = aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
Console.WriteLine("Ready with license.");
}
catch (Exception exc)
{
// If it fails at this point, shutdown the test and ignore any subsequent errors.
Console.WriteLine(exc.Message);
}
#endregion
try
{
#region Setup MD Parameters
MDParameters.gdbParentFolder = @"c:\temp\CreateMD";
// Choose which type of gdb to create/open.
// 0 - Create File Gdb
// 1 - Create Personal Gdb
// 2 - Open SDE
int gdbOption = 0;
// Provide the proper extension based on the gdb you want to create.
// e.g. MDParameters.gdbName = "samplePGdb.mdb" to create a personal gdb.
// To use an SDE, set SDE connection properties below.
MDParameters.gdbName = @"sampleGdb.gdb";
MDParameters.mosaicDatasetName = @"sampleMD";
// Specify the srs of the mosaic dataset
ISpatialReferenceFactory spatialrefFactory = new SpatialReferenceEnvironmentClass();
MDParameters.mosaicDatasetSrs = spatialrefFactory.CreateProjectedCoordinateSystem(
(int)(esriSRProjCSType.esriSRProjCS_World_Mercator));
// 0 and PT_UNKNOWN for bits and bands = use defaults.
MDParameters.mosaicDatasetBands = 0;
MDParameters.mosaicDatasetBits = rstPixelType.PT_UNKNOWN;
MDParameters.configKeyword = "";
// Product Definition key choices:
// None
// NATURAL_COLOR_RGB
// NATURAL_COLOR_RGBI
// FALSE_COLOR_IRG
// FORMOSAT-2_4BANDS
// GEOEYE-1_4BANDS
// IKONOS_4BANDS
// KOMPSAT-2_4BANDS
// LANDSAT_6BANDS
// LANDSAT_MSS_4BANDS
// QUICKBIRD_4BANDS
// RAPIDEYE_5BANDS
// SPOT-5_4BANDS
// WORLDVIEW-2_8BANDS
// Setting this property ensures any data added to the MD with its
// metadata defined gets added with the correct band combination.
MDParameters.productDefinitionKey = "FALSE_COLOR_IRG";
MDParameters.rasterTypeName = "QuickBird";
// The next two properties can be left blank for defaults
// The product filter defines which specific product of the raster
// type to add, e.g. To specfiy Quickbird Basic use value "Basic"
MDParameters.rasterTypeProductFilter = "";
// The product name specifies which template to use when adding data.
// e.g. "Pansharpen and Multispectral" means both multispectral and
// pansharpened rasters are added to the mosaic dataset.
MDParameters.rasterTypeProductName = "Multispectral";
// Data source from which to read the data.
MDParameters.dataSource = //@"\\Qalab_server\data\Raster\DOTNET\Input\DatasourcesRaster\FunctionRasterDataset\RasterDataset";
@"\\qalab_server\data\Raster\DOTNET\Input\DatasourcesRaster\MosaicDataset\QB\Torino";
//@"\\isdemo1\0_sampledata\SampleData\DataSets\QBBasic1b\Baghdad\X0388";
MDParameters.dataSourceFilter = @"";
// No need to set if data source has an srs or if you want to use the MD srs as data source srs.
MDParameters.dataSourceSrs = null;
MDParameters.buildOverviews = true;
#endregion
MDParameters.emptyFgdbFolder = true;
MDParameters.createFgdbParentFolder = false;
#region Empty/Create Output Directory
if (MDParameters.emptyFgdbFolder)
{
try
{
Console.WriteLine("Emptying Output Directory");
Directory.Delete(MDParameters.gdbParentFolder, true);
Directory.CreateDirectory(MDParameters.gdbParentFolder);
}
catch (Exception)
{
}
}
if (MDParameters.createFgdbParentFolder && !System.IO.Directory.Exists(MDParameters.gdbParentFolder))
{
Console.WriteLine("Creating Output Directory");
Directory.CreateDirectory(MDParameters.gdbParentFolder);
}
#endregion
CreateMD createMD = new CreateMD();
if (gdbOption == 0)
{
#region Create MD in File GDB
Console.WriteLine("Creating File GDB: " + MDParameters.gdbName);
IWorkspace fgdbWorkspace = CreateFileGdbWorkspace(MDParameters.gdbParentFolder, MDParameters.gdbName);
createMD.CreateMosaicDataset(fgdbWorkspace);
#endregion
}
else if (gdbOption == 1)
{
#region Create MD in Personal GDB
Console.WriteLine("Creating Personal GDB: " + MDParameters.gdbName);
IWorkspace pGdbWorkspace = CreateAccessWorkspace(MDParameters.gdbParentFolder, MDParameters.gdbName);
createMD.CreateMosaicDataset(pGdbWorkspace);
#endregion
}
else if (gdbOption == 2)
{
#region Open SDE GDB
// Set SDE connection properties.
IPropertySet sdeProperties = new PropertySetClass();
sdeProperties.SetProperty("SERVER", "barbados");
sdeProperties.SetProperty("INSTANCE", "9411");
sdeProperties.SetProperty("VERSION", "sde.DEFAULT");
sdeProperties.SetProperty("USER", "gdb");
sdeProperties.SetProperty("PASSWORD", "gdb");
sdeProperties.SetProperty("DATABASE", "VTEST");
IWorkspace sdeWorkspace = CreateSdeWorkspace(sdeProperties);
if (sdeWorkspace == null)
{
Console.WriteLine("Could not open SDE workspace: ");
return;
}
#endregion
#region Create MD in SDE
MDParameters.mosaicDatasetName = @"sampleMD";
createMD.CreateMosaicDataset(sdeWorkspace);
#endregion
}
#region Shutdown
Console.WriteLine("Press any key...");
Console.ReadKey();
// Shutdown License
aoInit.Shutdown();
#endregion
}
catch (Exception exc)
{
#region Report
Console.WriteLine("Exception Caught in Main: " + exc.Message);
Console.WriteLine("Shutting down.");
#endregion
#region Shutdown
Console.WriteLine("Press any key...");
Console.ReadKey();
// Shutdown License
aoInit.Shutdown();
#endregion
}
}
public void InitTest()
{
RuntimeManager.Bind(ProductCode.Desktop);
AoInitialize aoInit = new AoInitializeClass();
aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeAdvanced);
}
internal static Boolean canDoRelates()
{
Boolean Result = false;
IAoInitialize theInit;
ILicenseInformation theLicense;
theInit = new AoInitializeClass();
theLicense = (ILicenseInformation)theInit;
String theProduct = theLicense.GetLicenseProductName(theInit.InitializedProduct());
if (theProduct == "esriLicenseProductCodeArcEditor" || theProduct == "esriLicenseProductCodeArcInfo") return true;
return Result;
}
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);
}
static void Main(string[] args)
{
ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.Server);
IAoInitialize aoInit = new AoInitializeClass();
aoInit.Initialize(esriLicenseProductCode.esriLicenseProductCodeArcServer);
IWorkspaceFactory2 workspaceFactory = new FileGDBWorkspaceFactoryClass();
string workspacePath = "C:\\Users\\Administrator\\Documents\\ArcGIS\\Default.gdb";
IWorkspace ws = workspaceFactory.OpenFromFile(workspacePath, 0);
IFeatureWorkspace workspace = ws as IFeatureWorkspace;
IFeatureClass inFC = workspace.OpenFeatureClass("test");
CopyAndLabel(inFC, workspace, "labeled_0");
}
