/// <summary>
/// 从指定路径（或连接字符串）中获取要素类
/// <para>①shp路径：返回该shp存储的要素类；</para>
/// <para>②mdb路径：返回该mdb数据库第一个要素类；</para>
/// <para>③dwg路径：返回该dwg数据集第一个要素类；</para>
/// <para>④shp目录：返回目录下第一个shp文件存储的要素类；</para>
/// <para>⑤gdb目录：返回gdb数据库第一个要素类；</para>
/// <para>⑥mdb文件路径[\DatasetName]\FeatureClassName：返回mdb数据库中指定名称或别名的要素类；</para>
/// <para>⑦gdb目录[\DatasetName]\FeatureClassName：返回gdb数据库中指定名称或别名的要素类；</para>
/// <para>⑧sde或oleDb或sql连接字符串：返回数据库中的第一个要素类；</para>
/// </summary>
/// <param name="connStrOrPath">路径或连接字符串</param>
/// <param name="autoAddExtension">是否自动在路径末尾增加.shp/.mdb/.dwg后缀，以再次查找要素类</param>
/// <returns></returns>
public static IFeatureClass FromPath(string connStrOrPath, bool autoAddExtension = false)
{
if (WorkspaceEx.IsConnectionString(connStrOrPath))
{
return(FirstFromConnString(connStrOrPath));
}
if (Directory.Exists(connStrOrPath))
{
return(FirstFormDir(connStrOrPath));
}
if (File.Exists(connStrOrPath))
{
return(FirstFormFile(connStrOrPath));
}
var featureClass = FirstFromFullPath(connStrOrPath);
if (autoAddExtension && featureClass == null)
{
foreach (var extension in new[] { ".shp", ".dwg", ".mdb" })
{
if (File.Exists(connStrOrPath + extension))
{
return(FirstFormFile(connStrOrPath + extension));
}
}
}
return(featureClass);
}
/// <summary>
/// 获取指定shp文件存储的要素类
/// </summary>
/// <param name="shpPath"></param>
/// <returns></returns>
private static IFeatureClass FromShpFile(string shpPath)
{
var dir = Path.GetDirectoryName(shpPath);
var fileName = Path.GetFileNameWithoutExtension(shpPath);
return(WorkspaceEx.GetWorkSpace(dir, EWorkspaceType.ShapeFile).GetFeatureClassByName(fileName));
}
/// <summary>
/// 创建要素类，该要素类仅存储在内存中
/// </summary>
/// <param name="name">要素类名称</param>
/// <param name="fields">要创建的字段集（必须包含SHAPE字段和OID字段），可参考<see cref="FieldOpt.CreateBaseFields"/>等方法创建字段集</param>
/// <param name="strWorkspaceName">内存工作空间的名称</param>
/// <returns></returns>
public static IFeatureClass CreateInMemory(string name, IFields fields, string strWorkspaceName = "InMemoryWorkspace")
{
var workspace = WorkspaceEx.NewInMemoryWorkspace(strWorkspaceName);
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
return(featureWorkspace.CreateFeatureClass(name, fields, null, null, esriFeatureType.esriFTSimple, "SHAPE", ""));
}
/// <summary>
/// 获取指定CAD的dwg数据集存储的要素类
/// </summary>
/// <param name="dwgPath">CAD的dwg数据集路径</param>
/// <returns></returns>
private static List <IFeatureClass> FromDwgFile(string dwgPath)
{
var dir = Path.GetDirectoryName(dwgPath);
var dataSetName = Path.GetFileNameWithoutExtension(dwgPath);
return(WorkspaceEx.GetWorkSpace(dir, EWorkspaceType.CAD).GetFeatureDataset(dataSetName).GetFeatureClasses());
}
/// <summary>
/// 相交分析，返回相交部分的要素（注意输入要素类和叠加要素类不能有空几何等问题）
/// </summary>
/// <param name="inClass">输入的要素类</param>
/// <param name="overlayClass">叠加的要素类</param>
/// <param name="outPath">保存分析结果的工作空间路径</param>
/// <param name="outName">保存分析结果的要素类名称</param>
/// <returns></returns>
public static IFeatureClass Intersect(this IFeatureClass inClass, IFeatureClass overlayClass, string outPath, string outName)
{
var workspaceType = WorkspaceEx.GetDefaultWorkspaceType(outPath);
if (workspaceType == EWorkspaceType.Default)
{
throw new Exception($"工作空间路径(outPath)不存在！{outPath} 该路径必须是已存在的mdb文件路径，或shp所在文件夹路径，或gdb文件夹路径，或sde连接字符串");
}
IFeatureClassName outClassName = new FeatureClassNameClass
{
ShapeType = inClass.ShapeType,
ShapeFieldName = inClass.ShapeFieldName,
FeatureType = esriFeatureType.esriFTSimple
};
IWorkspaceName workspaceName = new WorkspaceNameClass
{
WorkspaceFactoryProgID = workspaceType.GetDescription(1),
PathName = outPath
};
IDatasetName datasetName = (IDatasetName)outClassName;
datasetName.Name = outName;
datasetName.WorkspaceName = workspaceName;
return(new BasicGeoprocessorClass().Intersect((ITable)inClass, false, (ITable)overlayClass, false, 0.01, outClassName));
}
/// <summary>
/// 获取指定连接字符串对应数据库存储的第一个要素类
/// </summary>
/// <param name="connString">连接字符串</param>
/// <returns></returns>
private static IFeatureClass FirstFromConnString(string connString)
{
var workspace = WorkspaceEx.GetWorkSpace(connString);
var featureClass = workspace.GetFirstFeatureClass();
Marshal.ReleaseComObject(workspace);
return(featureClass);
}
/// <summary>
/// 获取指定全路径下的要素类，全路径形式为：“工作空间路径[\要素集名称][\要素类名称]”
/// </summary>
/// <param name="fullPath">格式为“工作空间路径[\要素集名称][\要素类名称]”的路径</param>
/// <returns></returns>
private static List <IFeatureClass> FromFullPath(string fullPath)
{
fullPath = fullPath.ToLower();
string workspacePath = null;
foreach (var extension in new[] { ".gdb", ".mdb" })
{
int index;
if ((index = fullPath.LastIndexOf(extension, StringComparison.OrdinalIgnoreCase)) > -1)
{
workspacePath = fullPath.Substring(0, index + 4);
break;
}
}
var classes = new List <IFeatureClass>();
IFeatureClass featureClass = null;
if (!string.IsNullOrWhiteSpace(workspacePath))//按照"\"或者"/"分割子路径，获得要素集名称、要素类名称
{
var workspace = WorkspaceEx.GetWorkSpace(workspacePath);
if (workspace == null)
{
throw new Exception($"无法按照指定路径或连接字符串“{workspacePath}”打开工作空间！");
}
var subPath = fullPath.Replace(workspacePath, "");
var names = subPath.Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);
if (names.Length == 1)
{
var dataset = workspace.GetFeatureDataset(names[0]);
if (dataset != null)
{
classes.AddRange(dataset.GetFeatureClasses());
}
else if ((featureClass = workspace.GetFeatureClassByName(names[0])) != null)
{
classes.Add(featureClass);
}
}
if (names.Length == 2)
{
featureClass = workspace.GetFeatureDataset(names[0])?.GetFeatureClassByName(names[1]);
classes.Add(featureClass);
}
}
if (fullPath.Contains(".dwg") &&
(featureClass = FromDwgFullPath(fullPath)) != null)
{
classes.Add(featureClass);
}
return(classes);
}
/// <summary>
/// 设置图层数据源
/// </summary>
/// <param name="layer">设置数据源的图层</param>
/// <param name="workspacePath">工作空间路径</param>
/// <param name="dataSetName">数据集名称，数据源不在数据集中则应为null</param>
/// <param name="objectName">图层关联对象的名称，即要素类名称或栅格数据集名称</param>
public static void SetSourcePath(this ILayer layer, string workspacePath, string dataSetName, string objectName)
{
if (!WorkspaceEx.IsWorkspacePath(workspacePath) &&
!WorkspaceEx.IsConnectionString(workspacePath))
{
throw new ArgumentException($"找不到数据源({workspacePath})，请指定正确的数据源！");
}
switch (layer)
{
case IFeatureLayer featureLayer:
if (featureLayer is IDataLayer dataLayer)
{
IDatasetName datasetName = (IDatasetName)dataLayer.DataSourceName;
EWorkspaceType eWorkspaceType = WorkspaceEx.GetDefaultWorkspaceType(workspacePath);
datasetName.WorkspaceName.WorkspaceFactoryProgID = eWorkspaceType.GetDescription(1);
datasetName.WorkspaceName.PathName = workspacePath;
//TODO:
if (!string.IsNullOrWhiteSpace(dataSetName))
{
datasetName.Category = dataSetName;
}
if (!string.IsNullOrWhiteSpace(objectName))
{
datasetName.Name = objectName;
}
}
break;
case IRasterLayer rasterLayer:
objectName = string.IsNullOrWhiteSpace(objectName)
? ((rasterLayer as IDataLayer)?.DataSourceName as IDatasetName)?.Name
: objectName;
if (objectName == null)
{
throw new Exception($"指定数据源名称（参数{nameof(objectName)}）不能为空！");
}
rasterLayer.CreateFromFilePath(!string.IsNullOrWhiteSpace(dataSetName)
? Path.Combine(workspacePath, dataSetName, objectName)
: Path.Combine(workspacePath, objectName));
break;
case IGroupLayer groupLayer:
throw new Exception("该图层对象为图层组(IGroupLayer)，无法设置图层组的数据源，请指定到具体的图层");
default:
throw new NotImplementedException(
"图层不是要素图层(IFeatureLayer)，也不是栅格图层(IRasterLayer)，未实现其他类型图层的数据源设置");
}
}
private void Test()
{
double sumRiverLength = 0.0;
FeatureClassEx.FromPath(@"c:\River.shp").QueryFeatures(@"XZQDM = '440000'",
feature => sumRiverLength += feature.ToDouble("RiverLength"));
var workspace = WorkspaceEx.GetWorkSpace(@"c:\World.mdb");
FeatureClassEx.FromPath(@"c:\World.mdb\river").CopyStruct(workspace, "NewRiver", "河流");
var connString = DbHelper.Dbf_OleDb4(@"c:\River.dbf");
var dbHelper = DbHelper.GetOleDbHelper(connString).ExcNonQuery(@"update River set Name = 'Pearl River' where RiverCode ='003'");
}
/// <summary>
/// 打开栅格数据集（bmp/tif/jpg/img）
/// </summary>
/// <param name="rasterPath">栅格数据文件的路径（bmp/tif/jpg/img）</param>
/// <returns></returns>
public static IRasterDataset GetRasterDataset(string rasterPath)
{
var dir = System.IO.Path.GetDirectoryName(rasterPath); //获取文件路径
var name = System.IO.Path.GetFileName(rasterPath); //获取栅格文件名
var workspace = WorkspaceEx.GetWorkSpace(dir, EWorkspaceType.Raster);
var rasterWorkspace = workspace as IRasterWorkspace;
if (rasterWorkspace == null)
{
throw new Exception($"指定的工作空间“{dir}”不是栅格数据集工作空间！");
}
return(rasterWorkspace.OpenRasterDataset(name));
}
/// <summary>
/// 获取指定路径或连接字符串对应数据库下，以数据库（工作空间）名为根节点，要素集或要素类为子节点的树结构信息
/// <para>在返回的<see cref="TreeNode"/>各级节点中，Tag属性为1代表要素类，0为要素数据集，-1为工作空间</para>
/// </summary>
/// <param name="strConnOrPath">路径或连接字符串，可以是gdb文件夹路径、shp所在目录、mdb文件路径或sde数据库连接字符串</param>
/// <returns></returns>
public static TreeNode DbToTreeNodes(string strConnOrPath)
{
SplitPath(strConnOrPath, out var workspacePath, out _, out _);
var workspaceName = Directory.Exists(workspacePath) ? new DirectoryInfo(workspacePath).Name : Path.GetFileNameWithoutExtension(workspacePath);
var rootNode = new TreeNode(workspaceName)
{
Tag = -1
};
var workspace = WorkspaceEx.GetWorkSpace(strConnOrPath);
//不放到dataset的要素数据
var dataset = workspace.Datasets[esriDatasetType.esriDTFeatureClass];
IFeatureClass featureClass;
while ((featureClass = dataset.Next() as IFeatureClass) != null)
{
rootNode.Nodes.Add(new TreeNode(featureClass.AliasName)
{
Tag = 1
});
}
//放到dataset里的要素
var enumDataset = workspace.Datasets[esriDatasetType.esriDTFeatureDataset];
IFeatureDataset featureDataset;
while ((featureDataset = enumDataset.Next() as IFeatureDataset) != null)//遍历数据集
{
var dataSetNode = new TreeNode(featureDataset.Name)
{
Tag = 0
};
var enumFeatureClass = ((IFeatureClassContainer)featureDataset).Classes;
while ((featureClass = enumFeatureClass.Next()) != null)//在每一个数据集中遍历数据层IFeatureClass
{
dataSetNode.Nodes.Add(new TreeNode(featureClass.AliasName)
{
Tag = 1
});
}
rootNode.Nodes.Add(dataSetNode);
}
return(rootNode);
}
/// <summary>
/// 从指定路径（或连接字符串）中获取全部要素类
/// <para>①shp路径：返回该shp存储的要素类；</para>
/// <para>②mdb路径：返回该mdb数据库的全部要素类；</para>
/// <para>③dwg路径：返回该dwg数据集的全部要素类；</para>
/// <para>④普通目录：返回目录下的全部shp和dwg要素类；</para>
/// <para>⑤gdb目录：返回gdb数据库的全部要素类；</para>
/// <para>⑥mdb文件路径[\DatasetName][\FeatureClassName]：返回mdb数据库中指定要素类，或指定数据集下的全部要素类；</para>
/// <para>⑦gdb目录[\DatasetName][\FeatureClassName]：返回gdb数据库中指定要素类，或指定数据集下的全部要素类；</para>
/// <para>⑧sde或oleDb或sql连接字符串：返回数据库的全部要素类；</para>
/// </summary>
/// <param name="connStrOrPath"></param>
/// <returns></returns>
public static List <IFeatureClass> AllFromPath(string connStrOrPath)
{
if (WorkspaceEx.IsConnectionString(connStrOrPath))
{
return(FromConnString(connStrOrPath));
}
if (Directory.Exists(connStrOrPath))
{
return(FromDir(connStrOrPath));
}
if (File.Exists(connStrOrPath))
{
return(FromFile(connStrOrPath));
}
return(FromFullPath(connStrOrPath));
}
/// <summary>
/// 获取指定路径或连接字符串对应数据库下，以数据库名为根节点，要素集或要素类为子节点的树结构信息
/// （如果节点为要素类则它的Tag属性为1，否则为0）
/// </summary>
/// <param name="strConnOrPath">路径或连接字符串，可以是gdb文件夹路径、shp所在目录、mdb文件路径或sde数据库连接字符串</param>
/// <returns></returns>
public static TreeNode GetDbSourceTreeNodes(string strConnOrPath)
{
var fileName = System.IO.Path.GetFileNameWithoutExtension(strConnOrPath);
var rootNode = new TreeNode(fileName)
{
Tag = 0
};
var workspace = WorkspaceEx.GetWorkSpace(strConnOrPath);
//不放到DataSet的要素数据
var dataset = workspace.Datasets[esriDatasetType.esriDTFeatureClass];
IFeatureClass featureClass;
while ((featureClass = dataset.Next() as IFeatureClass) != null)
{
rootNode.Nodes.Add(new TreeNode(featureClass.AliasName)
{
Tag = 1
});
}
//放到Dataset里的要素
var enumDataset = workspace.Datasets[esriDatasetType.esriDTFeatureDataset];
IFeatureDataset featureDataset;
while ((featureDataset = enumDataset.Next() as IFeatureDataset) != null)//遍历数据集
{
var dataSetNode = new TreeNode(featureDataset.Name)
{
Tag = 0
};
var enumFeatureClass = ((IFeatureClassContainer)featureDataset).Classes;
while ((featureClass = enumFeatureClass.Next()) != null)//在每一个数据集中遍历数据层IFeatureClass
{
dataSetNode.Nodes.Add(new TreeNode(featureClass.AliasName)
{
Tag = 1
});
}
rootNode.Nodes.Add(dataSetNode);
}
return(rootNode);
}
/// <summary>
/// 在指定目录（shp目录）或地理数据库（mdb/gdb/sde/sql）中创建新的要素类，并返回该要素类（注意路径中不能存在同名要素类）
/// </summary>
/// <param name="geoDbPath">mdb文件路径，或shp所在文件夹路径，或gdb文件夹路径，或sde/sql数据库连接字符串</param>
/// <param name="datasetName">要素数据集名称，若赋值为null则直接在数据库下创建要素类，否则在该要素数据集(不存在则创建)下创建要素类</param>
/// <param name="className">需要创建的要素类名称</param>
/// <param name="fields">字段集合（应包含OID和Shape字段）</param>
/// <returns></returns>
public static IFeatureClass CreateToDb(string geoDbPath, string datasetName, string className, IFields fields)
{
var workspace = WorkspaceEx.GetWorkSpace(geoDbPath);
var spatialRef = fields.GetSpatialRef();
IFeatureClass featureClass;
if (!string.IsNullOrEmpty(datasetName))
{
var featureDataset = workspace.GetFeatureDataset(datasetName) ?? workspace.CreateFeatureDataset(datasetName, spatialRef);
featureClass = featureDataset.CreateFeatureClass(className, fields, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
Marshal.ReleaseComObject(featureDataset);
}
else
{
featureClass = (workspace as IFeatureWorkspace)?.CreateFeatureClass(className, fields, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
}
Marshal.ReleaseComObject(workspace);
return(featureClass);
}
/// <summary>
/// 在指定目录（shp目录）或地理数据库（shp/mdb/gdb/sde/sql）中创建新的要素类，并返回该要素类（注意路径中不能存在同名要素类）
/// </summary>
/// <param name="geoDbPath">mdb文件路径，或shp所在文件夹路径，或gdb文件夹路径，或sde/sql数据库连接字符串</param>
/// <param name="datasetName">要素数据集名称，若赋值为null则直接在数据库下创建要素类，否则在该要素数据集(不存在则创建)下创建要素类</param>
/// <param name="className">需要创建的要素类名称</param>
/// <param name="geoType">要素类的几何类型</param>
/// <param name="spatialRef">空间参考（坐标系），创建方法参考<see cref="SpatialRefOpt.CreateSpatialRef(int, ESrType)"/>及该方法的重载</param>
/// <param name="otherFields">除了OID和SHAPE字段的其他字段</param>
/// <returns></returns>
public static IFeatureClass CreateToDb(string geoDbPath, string datasetName, string className, esriGeometryType geoType,
ISpatialReference spatialRef, IEnumerable <IField> otherFields = null)
{
var fields = FieldOpt.CreateFields(geoType, spatialRef, otherFields);
var workspace = WorkspaceEx.GetWorkSpace(geoDbPath);
IFeatureClass featureClass;
if (!string.IsNullOrEmpty(datasetName))
{
var featureDataset = workspace.GetFeatureDataset(datasetName) ?? workspace.CreateFeatureDataset(datasetName, spatialRef);
featureClass = featureDataset.CreateFeatureClass(className, fields, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
Marshal.ReleaseComObject(featureDataset);
}
else
{
featureClass = Create(workspace, className, spatialRef, geoType, fields);
}
Marshal.ReleaseComObject(workspace);
return(featureClass);
}
/// <summary>
/// 获取指定CAD的dwg数据集存储的第一个要素类
/// </summary>
/// <param name="dwgLayerPath">指向dwg图层的完整路径：dwg文件路径\图层名</param>
/// <returns></returns>
private static IFeatureClass FromDwgFullPath(string dwgLayerPath)
{
var index = dwgLayerPath.LastIndexOf(dwgLayerPath, StringComparison.OrdinalIgnoreCase);
if (index < 0)
{
throw new Exception($"获取CAD要素类失败，“{dwgLayerPath}”不是有效的dwg数据路径！");
}
var dwgPath = dwgLayerPath.Substring(0, index + 4);
if (!File.Exists(dwgPath))
{
throw new Exception("获取要素类失败，找不到指定路径：" + dwgPath);
}
var dwgDir = Path.GetDirectoryName(dwgPath);
var dataSetName = Path.GetFileNameWithoutExtension(dwgPath);
var layerName = dwgLayerPath.Replace(dwgPath, "");
return(WorkspaceEx.GetWorkSpace(dwgDir, EWorkspaceType.CAD).GetFeatureDataset(dataSetName).GetFeatureClassByName(layerName));
}
/// <summary>
/// 获取指定路径或连接字符串对应数据库下，以数据库（工作空间）名为根节点，要素集或要素类为子节点的树结构信息
/// <para>在返回的<see cref="NodeObject"/>对象中，NodeTag属性为1代表要素类，0为要素数据集，-1为工作空间</para>
/// </summary>
/// <param name="strConnOrPath">路径或连接字符串，可以是gdb文件夹路径、shp所在目录、mdb文件路径或sde数据库连接字符串</param>
/// <param name="getTopNode">是否获取顶层节点，即工作空间节点</param>
/// <returns></returns>
public static List <NodeObject> DbToNodeObjects(string strConnOrPath, bool getTopNode = true)
{
var nodes = new List <NodeObject>();
int id = 0;
if (getTopNode)
{
SplitPath(strConnOrPath, out var workspacePath, out _, out _);
var workspaceName = Directory.Exists(workspacePath) ? new DirectoryInfo(workspacePath).Name : Path.GetFileNameWithoutExtension(workspacePath);
nodes.Add(new NodeObject(id++, -1, workspaceName, 0, -1, workspaceName));
}
var workspace = WorkspaceEx.GetWorkSpace(strConnOrPath);
//不放到dataset的要素数据
var dataset = workspace.Datasets[esriDatasetType.esriDTFeatureClass];
IFeatureClass featureClass;
while ((featureClass = dataset.Next() as IFeatureClass) != null)
{
nodes.Add(new NodeObject(id++, 0, featureClass.AliasName, 0, 1, featureClass.GetName()));
}
//放到dataset里的要素
var enumDataset = workspace.Datasets[esriDatasetType.esriDTFeatureDataset];
IFeatureDataset featureDataset;
while ((featureDataset = enumDataset.Next() as IFeatureDataset) != null)//遍历数据集
{
int datasetId = id;
nodes.Add(new NodeObject(datasetId, 0, featureDataset.Name, 0, 0, featureClass.GetName()));
var enumFeatureClass = ((IFeatureClassContainer)featureDataset).Classes;
while ((featureClass = enumFeatureClass.Next()) != null)//在每一个数据集中遍历数据层IFeatureClass
{
nodes.Add(new NodeObject(id++, datasetId, featureClass.AliasName, 0, 1, featureClass.GetName()));
}
}
return(nodes);
}
/// <summary>
/// 在指定路径(shp/mdb/gdb)中创建新的要素类，并返回该要素类（注意路径中不能存在同名要素类）
/// </summary>
/// <param name="fullPath">
/// 要素类的完整保存路径，包含以下情况：
/// ①shp文件路径，创建shp文件；若shp文件所在目录不存在则自动创建；
/// ②mdb文件路径[\DatasetName]\FeatureClassName，在mdb中或mdb的指定要素集中，创建指定名称的图层；若mdb或要素集不存在则自动创建；
/// ③gdb目录[\DatasetName]\FeatureClassName，在gdb中或gdb的指定要素集中，创建指定名称的图层；若gdb或要素集不存在则自动创建；
/// </param>
/// <param name="fields">要创建的字段集，必须包含OID和SHAPE字段，创建字段集可参考<see cref="FieldOpt.CreateBaseFields"/>等方法</param>
/// <returns></returns>
public static IFeatureClass CreateToPath(string fullPath, IFields fields)
{
const string _shp = ".shp", _mdb = ".mdb", _gdb = ".gdb";
var chars = Path.GetInvalidPathChars();
foreach (var c in chars)
{
if (fullPath.Contains(c))
{
throw new Exception("路径不符合规范，文件路径不能包含以下字符串：" + string.Concat(chars));
}
}
fullPath = fullPath.ToLower();
if (fullPath.EndsWith(_shp))
{
var dir = Path.GetDirectoryName(fullPath);
if (dir != null)
{
Directory.CreateDirectory(dir);
return(CreateToDb(Path.GetDirectoryName(fullPath), Path.GetFileNameWithoutExtension(fullPath), null, fields));
}
}
else if (fullPath.Contains(_mdb))
{
var dbPath = fullPath.Substring(0, fullPath.IndexOf(_mdb, StringComparison.OrdinalIgnoreCase));
if (!File.Exists(dbPath))
{
var workspace = WorkspaceEx.NewWorkspace(EWorkspaceType.Access, Path.GetDirectoryName(dbPath), Path.GetFileNameWithoutExtension(dbPath));
Marshal.ReleaseComObject(workspace);
}
var names = fullPath.Replace(dbPath, "").Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);
if (names.Length == 1)
{
return(CreateToDb(dbPath, null, names[0], fields));
}
if (names.Length == 2)
{
return(CreateToDb(dbPath, names[0], names[1], fields));
}
}
else if (fullPath.Contains(_gdb))
{
var dbPath = fullPath.Substring(0, fullPath.IndexOf(_gdb, StringComparison.OrdinalIgnoreCase));
if (!Directory.Exists(dbPath))
{
var dirInfo = new DirectoryInfo(dbPath);
if (dirInfo.Parent == null)
{
throw new Exception($"路径“{dbPath}”不是有效的文件地理数据库路径！");
}
var workspace = WorkspaceEx.NewWorkspace(EWorkspaceType.FileGDB, dirInfo.Parent.FullName, dirInfo.Name);
Marshal.ReleaseComObject(workspace);
}
var names = fullPath.Replace(dbPath, "").Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);
if (names.Length == 1)
{
return(CreateToDb(dbPath, null, names[0], fields));
}
if (names.Length == 2)
{
return(CreateToDb(dbPath, names[0], names[1], fields));
}
}
return(null);
}
/// <summary>
/// 获取指定连接字符串对应数据库存储的第一个要素类
/// </summary>
/// <param name="connString">连接字符串</param>
/// <returns></returns>
private static IFeatureClass FirstFromConnString(string connString)
{
return(WorkspaceEx.GetWorkSpace(connString).GetFirstFeatureClass());
}
/// <summary>
/// 将工作空间的所有要素类加载到地图控件中，图层名使用要素类别名
/// </summary>
/// <param name="mapControl">地图控件</param>
/// <param name="strConOrPath">工作空间的路径，或者是sde的连接字符串</param>
/// <param name="zoomToClass">指定要素类名称或别名，地图将缩放到此要素类的显示范围</param>
public static void LoadAllFeatureLayers(this AxMapControl mapControl, string strConOrPath, string zoomToClass = null)
{
var workspace = WorkspaceEx.GetWorkSpace(strConOrPath);
LoadAllFeatureLayers(mapControl, workspace, zoomToClass);
}
/// <summary>
/// 获取指定CAD的dwg工作空间存储的第一个要素类
/// </summary>
/// <param name="dwgDir">CAD的dwg数据集路径</param>
/// <returns></returns>
private static IFeatureClass FirstFromDwgDir(string dwgDir)
{
return(WorkspaceEx.GetWorkSpace(dwgDir, EWorkspaceType.CAD).GetFirstFeatureClass());
}
/// <summary>
/// 获取指定shp目录存储的全部要素类
/// </summary>
/// <param name="shpDir"></param>
/// <returns></returns>
private static List <IFeatureClass> FromShpDir(string shpDir)
{
return(WorkspaceEx.GetWorkSpace(shpDir, EWorkspaceType.ShapeFile).GetFeatureClasses());
}
/// <summary>
/// 获取指定连接字符串对应数据库存储的全部要素类
/// </summary>
/// <param name="connString">连接字符串</param>
/// <returns></returns>
private static List <IFeatureClass> FromConnString(string connString)
{
return(WorkspaceEx.GetWorkSpace(connString).GetFeatureClasses());
}
/// <summary>
/// 获取指定目录下全部CAD的dwg数据集存储的要素类
/// </summary>
/// <param name="dwgDir">CAD的dwg数据集所在目录</param>
/// <returns></returns>
private static List <IFeatureClass> FromDwgDir(string dwgDir)
{
return(WorkspaceEx.GetWorkSpace(dwgDir, EWorkspaceType.CAD).GetFeatureClasses());
}
/// <summary>
/// 获取指定mdb数据库存储的全部要素类
/// </summary>
/// <param name="mdbPath"></param>
/// <returns></returns>
private static List <IFeatureClass> FromMdb(string mdbPath)
{
return(WorkspaceEx.GetWorkSpace(mdbPath, EWorkspaceType.Access).GetFeatureClasses());
}
/// <summary>
/// 获取指定gdb数据库存储的全部要素类
/// </summary>
/// <param name="gdbPath"></param>
/// <returns></returns>
private static List <IFeatureClass> FromGdb(string gdbPath)
{
return(WorkspaceEx.GetWorkSpace(gdbPath, EWorkspaceType.FileGDB).GetFeatureClasses());
}
