public IFeatureClass CreateFeatureClass(string Name, IFields Fields, UID CLSID, UID EXTCLSID, esriFeatureType FeatureType, string ShapeFieldName, string ConfigKeyword)
{
// See ExecuteSQL() for argument.
throw new NotImplementedException();
}
private void AddTemplate(YTEditTemplate template)
{
List <YTEditTemplate> list;
ListViewGroup group;
ListViewItem item;
string str;
IFeatureLayer featureLayer = template.FeatureLayer;
if (!m_list.ContainsKey(featureLayer))
{
list = new List <YTEditTemplate>();
m_list.Add(featureLayer, list);
}
else
{
list = m_list[featureLayer];
}
list.Add(template);
if (this.m_GroupType != GroupType.GroupByLayer)
{
if (this.m_GroupType != GroupType.GroupByGeometryType)
{
if (this.IsAdd(featureLayer))
{
item = new ListViewItem
{
Text = template.Name,
Tag = template
};
this.listView1.AddItem(item);
}
return;
}
esriGeometryType shapeType = template.FeatureLayer.FeatureClass.ShapeType;
esriFeatureType featureType = template.FeatureLayer.FeatureClass.FeatureType;
str = "";
if (featureType == esriFeatureType.esriFTAnnotation)
{
str = "注记";
}
else
{
switch (shapeType)
{
case esriGeometryType.esriGeometryPolyline:
str = "线";
break;
case esriGeometryType.esriGeometryPolygon:
str = "面";
break;
case esriGeometryType.esriGeometryPoint:
case esriGeometryType.esriGeometryMultipoint:
str = "点";
break;
}
}
group = null;
foreach (ListViewGroup group2 in this.listView1.Groups)
{
if (group2.Name == str)
{
group = group2;
break;
}
}
}
else
{
group = null;
foreach (ListViewGroup group2 in this.listView1.Groups)
{
if (group2.Tag == featureLayer)
{
group = group2;
break;
}
}
if ((group == null) && this.IsAdd(featureLayer))
{
group = new ListViewGroup
{
Tag = featureLayer,
Name = featureLayer.Name,
Header = featureLayer.Name
};
this.listView1.Groups.Add(group);
}
if (group != null)
{
item = new ListViewItem
{
Text = template.Name,
Tag = template,
Group = group
};
this.listView1.AddItem(item);
}
return;
}
if ((group == null) && this.IsAdd(featureLayer))
{
group = new ListViewGroup
{
Name = str,
Header = str
};
this.listView1.Groups.Add(group);
}
if (group != null)
{
item = new ListViewItem
{
Text = template.Name,
Tag = template,
Group = group
};
this.listView1.AddItem(item);
}
}
public IFeatureClass createFeatureClassInMemory(string strName, IFields FeatureFields, IWorkspace pWS, esriFeatureType featType)
{
ESRI.ArcGIS.esriSystem.UID CLSID = null;
//ESRI.ArcGIS.esriSystem.UID CLSEXT = null;
IFeatureWorkspace pFWS = null;
ESRI.ArcGIS.Geodatabase.IFieldChecker fieldChecker = null;
ESRI.ArcGIS.Geodatabase.IEnumFieldError enumFieldError = null;
ESRI.ArcGIS.Geodatabase.IFields validatedFields = null;
try
{
//CLSEXT = null;
pFWS = (IFeatureWorkspace)pWS;
if (CLSID == null)
{
CLSID = new ESRI.ArcGIS.esriSystem.UIDClass();
CLSID.Value = "esriGeoDatabase.Feature";
}
fieldChecker = new ESRI.ArcGIS.Geodatabase.FieldCheckerClass();
enumFieldError = null;
validatedFields = null;
fieldChecker.ValidateWorkspace = pWS;
fieldChecker.Validate(FeatureFields, out enumFieldError, out validatedFields);
bool FCCreated = false;
IFeatureClass newFeat = null;
int loopCnt = 0;
while (FCCreated == false)
{
try
{
if (loopCnt == 0)
{
loopCnt = loopCnt + 1;
newFeat = pFWS.CreateFeatureClass(strName, validatedFields, null, null, featType, "SHAPE", "");
}
else
{
loopCnt = loopCnt + 1;
newFeat = pFWS.CreateFeatureClass(strName + (loopCnt - 1).ToString(), validatedFields, null, null, featType, "SHAPE", "");
}
FCCreated = true;
}
catch
{
FCCreated = false;
}
if (loopCnt == 100)
FCCreated = true;
}
return newFeat;
}
catch
{
return null;
}
finally
{
CLSID = null;
pFWS = null;
fieldChecker = null;
enumFieldError = null;
validatedFields = null;
}
}
/// <summary>
/// 创建要素类
/// </summary>
/// <param name="obj">IWorkspace、IFeatureWorkspace或IFeatureDataset对象，在该对象中创建要素类</param>
/// <param name="name">要素类名称（如果为shapefile,不能包含文件扩展名.shp）</param>
/// <param name="spatialRef">空间参考坐标系。若参数obj为IFeatureDataset则应赋值为null；否则不能为null，
/// 可使用<see cref="SpatialRefOpt.CreateSpatialRef(esriSRProjCS4Type)"/>或其重载方法进行创建</param>
/// <param name="featureType">要素类型</param>
/// <param name="geometryType">几何类型</param>
/// <param name="fields">要创建的字段集（可以为null，该方法自动修改或加入OID和SHAPE字段以确保几何类型、坐标系与参数一致）</param>
/// <param name="uidClsId">CLSID值（可以为Null）</param>
/// <param name="uidClsExt">EXTCLSID值（可以为Null）</param>
/// <param name="configWord">配置信息关键词（可以为""）</param>
/// <returns>返回IFeatureClass</returns>
public static IFeatureClass Create(object obj, string name, ISpatialReference spatialRef, esriFeatureType featureType,
esriGeometryType geometryType, IFields fields, UID uidClsId, UID uidClsExt, string configWord)
{
#region 错误检测
if (obj == null)
{
throw new Exception("参数[obj]不能为空!");
}
if (!(obj is IWorkspace || obj is IFeatureWorkspace || obj is IFeatureDataset))
{
throw new Exception("参数[obj]必须为IFeatureWorkspace或者IFeatureDataset");
}
if (name.Length == 0)
{
throw new Exception("参数[name]不能为空!");
}
if ((obj is IWorkspace || obj is IFeatureWorkspace) && spatialRef == null)
{
throw new Exception("参数[spatialRef]不能为空(对于单独的要素类)");
}
#endregion
#region uidClsId字段为空时
if (uidClsId == null)
{
uidClsId = new UIDClass();
switch (featureType)
{
case esriFeatureType.esriFTSimple:
if (geometryType == esriGeometryType.esriGeometryLine)
{
geometryType = esriGeometryType.esriGeometryPolyline;
}
uidClsId.Value = "{52353152-891A-11D0-BEC6-00805F7C4268}";
break;
case esriFeatureType.esriFTSimpleJunction:
geometryType = esriGeometryType.esriGeometryPoint;
uidClsId.Value = "{CEE8D6B8-55FE-11D1-AE55-0000F80372B4}";
break;
case esriFeatureType.esriFTComplexJunction:
uidClsId.Value = "{DF9D71F4-DA32-11D1-AEBA-0000F80372B4}";
break;
case esriFeatureType.esriFTSimpleEdge:
geometryType = esriGeometryType.esriGeometryPolyline;
uidClsId.Value = "{E7031C90-55FE-11D1-AE55-0000F80372B4}";
break;
case esriFeatureType.esriFTComplexEdge:
geometryType = esriGeometryType.esriGeometryPolyline;
uidClsId.Value = "{A30E8A2A-C50B-11D1-AEA9-0000F80372B4}";
break;
case esriFeatureType.esriFTAnnotation:
geometryType = esriGeometryType.esriGeometryPolygon;
uidClsId.Value = "{E3676993-C682-11D2-8A2A-006097AFF44E}";
break;
case esriFeatureType.esriFTDimension:
geometryType = esriGeometryType.esriGeometryPolygon;
uidClsId.Value = "{496764FC-E0C9-11D3-80CE-00C04F601565}";
break;
}
}
#endregion
#region uidClsExt字段为空时
if (uidClsExt == null)
{
switch (featureType)
{
case esriFeatureType.esriFTAnnotation:
uidClsExt = new UIDClass();
uidClsExt.Value = "{24429589-D711-11D2-9F41-00C04F6BC6A5}";
break;
case esriFeatureType.esriFTDimension:
uidClsExt = new UIDClass();
uidClsExt.Value = "{48F935E2-DA66-11D3-80CE-00C04F601565}";
break;
}
}
#endregion
#region 添加OID和SHAPE字段
if (fields == null)
{
fields = new FieldsClass();
}
fields.AddBaseFields(geometryType, spatialRef);
#endregion
if (obj is IFeatureWorkspace featureWorkspace) //创建独立的FeatureClass
{
return(featureWorkspace.CreateFeatureClass(name, fields, null, uidClsExt, featureType, "SHAPE", configWord));
}
else//在要素集中创建FeatureClass
{
return(((IFeatureDataset)obj).CreateFeatureClass(name, fields, uidClsId, uidClsExt, featureType, "SHAPE", configWord));
}
}
private void InitControl()
{
if (DesignMode)
{
return;
}
ListViewGroup group;
ListViewItem item;
this.SetToolItemCheck();
this.listView1.Groups.Clear();
this.listView1.Items.Clear();
if (this.m_GroupType == GroupType.GroupByLayer)
{
if (m_list == null)
{
return;
}
foreach (KeyValuePair <IFeatureLayer, List <YTEditTemplate> > pair in m_list)
{
if (this.IsAdd(pair.Key))
{
group = new ListViewGroup
{
Tag = pair.Key,
Name = pair.Key.Name,
Header = pair.Key.Name
};
this.listView1.Groups.Add(group);
if (pair.Value != null)
{
foreach (YTEditTemplate template in pair.Value)
{
item = new ListViewItem
{
Text = template.Name,
Tag = template,
Group = group
};
this.listView1.AddItem(item);
}
}
}
}
}
else if (this.m_GroupType == GroupType.GroupByGeometryType)
{
ListViewGroup group2 = null;
ListViewGroup group3 = null;
ListViewGroup group4 = null;
ListViewGroup group5 = null;
foreach (KeyValuePair <IFeatureLayer, List <YTEditTemplate> > pair in m_list)
{
if (!this.IsAdd(pair.Key))
{
continue;
}
esriGeometryType shapeType = pair.Key.FeatureClass.ShapeType;
esriFeatureType featureType = pair.Key.FeatureClass.FeatureType;
group = null;
if (featureType == esriFeatureType.esriFTAnnotation)
{
if (group5 == null)
{
group5 = new ListViewGroup
{
Name = "注记",
Header = "注记"
};
}
group = group5;
}
else
{
switch (shapeType)
{
case esriGeometryType.esriGeometryPolyline:
if (group3 == null)
{
group3 = new ListViewGroup
{
Name = "线",
Header = "线"
};
}
group = group3;
goto Label_0337;
case esriGeometryType.esriGeometryPolygon:
if (group2 == null)
{
group2 = new ListViewGroup
{
Name = "面",
Header = "面"
};
}
group = group2;
goto Label_0337;
}
if ((shapeType != esriGeometryType.esriGeometryPoint) &&
(shapeType != esriGeometryType.esriGeometryMultipoint))
{
continue;
}
if (group4 == null)
{
group4 = new ListViewGroup
{
Name = "点",
Header = "点"
};
}
group = group4;
}
Label_0337:
this.listView1.Groups.Add(group);
if (pair.Value != null)
{
foreach (YTEditTemplate template in pair.Value)
{
item = new ListViewItem
{
Text = template.Name,
Tag = template,
Group = group
};
this.listView1.AddItem(item);
}
}
}
}
else
{
foreach (KeyValuePair <IFeatureLayer, List <YTEditTemplate> > pair in m_list)
{
if (this.IsAdd(pair.Key) && (pair.Value != null))
{
foreach (YTEditTemplate template in pair.Value)
{
item = new ListViewItem
{
Text = template.Name,
Tag = template
};
this.listView1.AddItem(item);
}
}
}
}
}
public static string GetDescription(esriFeatureType type) {
switch (type) {
case esriFeatureType.esriFTAnnotation: return "Annotation";
case esriFeatureType.esriFTComplexEdge: return "Complex Edge";
case esriFeatureType.esriFTComplexJunction: return "Complex Junction";
case esriFeatureType.esriFTCoverageAnnotation: return "Coverage Annotation";
case esriFeatureType.esriFTDimension: return "Dimension";
case esriFeatureType.esriFTRasterCatalogItem: return "Raster Catalog";
case esriFeatureType.esriFTSimple: return "Simple";
case esriFeatureType.esriFTSimpleEdge: return "Simple Edge";
case esriFeatureType.esriFTSimpleJunction: return "Simple Junction";
default:
return "UNKNOWN";
}
}
//ShapeFile 投影转换
public override bool Transform()
{
//获取源文件IFeatureClass
//首先获取文件名，文件路径及文件类型
string filename = "";
string url = "";
string file_ext = "";
this.SplitShapeFilePath(this.ImportShapeFile, ref filename, ref url, ref file_ext);
//----
ShapefileWorkspaceFactoryClass wsf = new ShapefileWorkspaceFactoryClass();
IWorkspace ws = wsf.OpenFromFile(url, 0);
IFeatureWorkspace pFeatureWorkspace;
pFeatureWorkspace = (IFeatureWorkspace)ws;
IFeatureClass pFeatureClass = null;
pFeatureClass = pFeatureWorkspace.OpenFeatureClass(filename);
//源文件投影空间参考
ISpatialReference SourceSpatialReference = this.getISpatialReference(pFeatureClass);
this.ImportSpatialReference = SourceSpatialReference;
//设置范围值
//this.SetSpatialReferenceDoMain(this.ImportSpatialReference, 0, 0, 999999999.99, 9999999.99);
//this.SetSpatialReferenceDoMain(this.ExportSpatialReference, 0, 0, 999999999.99, 9999999.99);
//目标文件投影空间参考
ISpatialReference ObjectSpatialReference = this.ExportSpatialReference;
if (SourceSpatialReference != null && ObjectSpatialReference != null)
{
//转换
//生成空的目标文件
string objfilename = "";
string objurl = "";
string objfile_ext = "";
this.SplitShapeFilePath(this.ExportShapeFile, ref objfilename, ref objurl, ref objfile_ext);
//----
ShapefileWorkspaceFactoryClass objwsf = new ShapefileWorkspaceFactoryClass();
IWorkspace objws = objwsf.OpenFromFile(objurl, 0);
IFeatureWorkspace objpFeatureWorkspace;
objpFeatureWorkspace = (IFeatureWorkspace)objws;
esriFeatureType featureType = esriFeatureType.esriFTSimple;
esriGeometryType GeometryType = esriGeometryType.esriGeometryNull;
featureType = pFeatureClass.FeatureType;
GeometryType = pFeatureClass.ShapeType;
//Create FeatureClass
IFeatureClass objFeatureClass = this.CreateFeatureClass(objpFeatureWorkspace, objfilename, featureType, GeometryType);
//copy 要素表字段结构
IFields Fields = pFeatureClass.Fields;
IField field = null;
for (int i = 0; i < Fields.FieldCount; i++)
{
field = Fields.get_Field(i);
if (objFeatureClass.Fields.FindField(field.Name) <= -1)
{
objFeatureClass.AddField(field);
}
}
//
this.ShapeFileProjectionConvert(SourceSpatialReference, ObjectSpatialReference, pFeatureClass, objFeatureClass);
objFeatureClass = null;
}
else
{
MessageBox.Show("源文件或目标文件的投影空间参考为空", "投影转换提示");
}
return(true);
}
public static IFeatureClass CreateFeatureClass(object object_0, string string_0,
ISpatialReference ispatialReference_0, esriFeatureType esriFeatureType_0,
esriGeometryType esriGeometryType_0, IFields ifields_0, UID uid_0, UID uid_1, string string_1)
{
if (object_0 == null)
{
throw new Exception("[objectWorkspace] 不能为空");
}
if ((object_0 is IWorkspace ? false : !(object_0 is IFeatureDataset)))
{
throw new Exception("[objectWorkspace] 必须是IWorkspace或IFeatureDataset");
}
if (string_0 == "")
{
throw new Exception("[name] cannot be empty");
}
if ((!(object_0 is IWorkspace) ? false : ispatialReference_0 == null))
{
throw new Exception("[spatialReference] cannot be null for StandAlong FeatureClasses");
}
if (uid_0 == null)
{
uid_0 = new UID();
switch (esriFeatureType_0)
{
case esriFeatureType.esriFTSimple:
{
uid_0.Value = "{52353152-891A-11D0-BEC6-00805F7C4268}";
break;
}
case esriFeatureType.esriFTSimpleJunction:
{
esriGeometryType_0 = esriGeometryType.esriGeometryPoint;
uid_0.Value = "{CEE8D6B8-55FE-11D1-AE55-0000F80372B4}";
break;
}
case esriFeatureType.esriFTSimpleEdge:
{
esriGeometryType_0 = esriGeometryType.esriGeometryPolyline;
uid_0.Value = "{E7031C90-55FE-11D1-AE55-0000F80372B4}";
break;
}
case esriFeatureType.esriFTComplexJunction:
{
uid_0.Value = "{DF9D71F4-DA32-11D1-AEBA-0000F80372B4}";
break;
}
case esriFeatureType.esriFTComplexEdge:
{
esriGeometryType_0 = esriGeometryType.esriGeometryPolyline;
uid_0.Value = "{A30E8A2A-C50B-11D1-AEA9-0000F80372B4}";
break;
}
case esriFeatureType.esriFTAnnotation:
{
esriGeometryType_0 = esriGeometryType.esriGeometryPolygon;
uid_0.Value = "{E3676993-C682-11D2-8A2A-006097AFF44E}";
break;
}
case esriFeatureType.esriFTDimension:
{
esriGeometryType_0 = esriGeometryType.esriGeometryPolygon;
uid_0.Value = "{496764FC-E0C9-11D3-80CE-00C04F601565}";
break;
}
}
}
if (uid_1 == null)
{
switch (esriFeatureType_0)
{
case esriFeatureType.esriFTAnnotation:
{
uid_1 = new UID()
{
Value = "{24429589-D711-11D2-9F41-00C04F6BC6A5}"
};
break;
}
case esriFeatureType.esriFTDimension:
{
uid_1 = new UID()
{
Value = "{48F935E2-DA66-11D3-80CE-00C04F601565}"
};
break;
}
}
}
if (ifields_0 == null)
{
ifields_0 = new Fields();
IFieldsEdit ifields0 = (IFieldsEdit)ifields_0;
IGeometryDef geometryDefClass = new GeometryDef();
IGeometryDefEdit esriGeometryType0 = (IGeometryDefEdit)geometryDefClass;
esriGeometryType0.GeometryType_2 = esriGeometryType_0;
esriGeometryType0.GridCount_2 = 1;
esriGeometryType0.GridSize_2[0] = 8555.04939799;
esriGeometryType0.AvgNumPoints_2 = 2;
esriGeometryType0.HasM_2 = false;
esriGeometryType0.HasZ_2 = false;
if (object_0 is IWorkspace)
{
esriGeometryType0.SpatialReference_2 = ispatialReference_0;
}
IField fieldClass = new Field();
IFieldEdit fieldEdit = (IFieldEdit)fieldClass;
fieldEdit.Name_2 = "OBJECTID";
fieldEdit.AliasName_2 = "OBJECTID";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeOID;
ifields0.AddField(fieldClass);
IField field = new Field();
IFieldEdit fieldEdit1 = (IFieldEdit)field;
fieldEdit1.Name_2 = "SHAPE";
fieldEdit1.AliasName_2 = "SHAPE";
fieldEdit1.Type_2 = esriFieldType.esriFieldTypeGeometry;
fieldEdit1.GeometryDef_2 = geometryDefClass;
ifields0.AddField(field);
}
string name = "";
int num = 0;
while (true)
{
if (num > ifields_0.FieldCount - 1)
{
break;
}
else if (ifields_0.Field[num].Type == esriFieldType.esriFieldTypeGeometry)
{
name = ifields_0.Field[num].Name;
break;
}
else
{
num++;
}
}
if (name == "")
{
throw new Exception("Cannot locate geometry field in FIELDS");
}
IFeatureClass featureClass = null;
if (object_0 is IWorkspace)
{
IFeatureWorkspace object0 = (IFeatureWorkspace)((IWorkspace)object_0);
featureClass = object0.CreateFeatureClass(string_0, ifields_0, uid_0, uid_1, esriFeatureType_0, name,
string_1);
}
else if (object_0 is IFeatureDataset)
{
IFeatureDataset featureDataset = (IFeatureDataset)object_0;
featureClass = featureDataset.CreateFeatureClass(string_0, ifields_0, uid_0, uid_1, esriFeatureType_0,
name, string_1);
}
return(featureClass);
}
public FeatureClass(SerializationInfo info, StreamingContext context) : base(info, context) {
this._featureType = (esriFeatureType)Enum.Parse(typeof(esriFeatureType), info.GetString("featureType"), true);
this._shapeType = (esriGeometryType)Enum.Parse(typeof(esriGeometryType), info.GetString("shapeType"), true);
this._shapeFieldName = info.GetString("shapeFieldName");
this._hasM = info.GetBoolean("hasM");
this._hasZ = info.GetBoolean("hasZ");
this._areaFieldName = info.GetString("areaFieldName");
this._lengthFieldName = info.GetString("lengthFieldName");
this._extent = info.GetValue("extent", typeof(Extent)) as Extent;
this._spatialReference = info.GetValue("spatialReference", typeof(SpatialReference)) as SpatialReference;
}
public IGeometricNetwork CreateGeometricNetwork(IFeatureDataset ifeatureDataset_1)
{
int i;
IGeometricNetwork geometricNetworkByName;
try
{
INetworkCollection ifeatureDataset1 = ifeatureDataset_1 as INetworkCollection;
INetworkLoader networkLoader = this.NetworkLoader;
INetworkLoader2 preserveEnabledValues = networkLoader as INetworkLoader2;
INetworkLoaderProps networkLoaderProp = networkLoader as INetworkLoaderProps;
networkLoader.FeatureDatasetName = ifeatureDataset_1.FullName as IFeatureDatasetName as IDatasetName;
networkLoader.NetworkName = this.Name;
UID uIDClass = new UIDClass();
UID gUIDSIMPLEEDGECLSID = new UIDClass();
UID gUIDSIMPLEJUNCTIONCLSID = new UIDClass();
uIDClass.Value = this.GUID_COMPLEXEDGE_CLSID;
gUIDSIMPLEEDGECLSID.Value = this.GUID_SIMPLEEDGE_CLSID;
gUIDSIMPLEJUNCTIONCLSID.Value = this.GUID_SIMPLEJUNCTION_CLSID;
if (!this.IsSnap)
{
networkLoader.SnapTolerance = preserveEnabledValues.MinSnapTolerance;
}
else
{
networkLoader.SnapTolerance = this.SnapTolerance;
}
for (i = 0; i < this.Weights.Count; i++)
{
BulidGeometryNetworkHelper.Weight item = this.Weights[i] as BulidGeometryNetworkHelper.Weight;
networkLoader.AddWeight(item.networkWeightName, item.weightType, item.bitGateSize);
}
bool flag = true;
bool flag1 = false;
for (i = 0; i < this.FeatureClassWraps.Count; i++)
{
BulidGeometryNetworkHelper.FeatureClassWrap featureClassWrap =
this.FeatureClassWraps[i] as BulidGeometryNetworkHelper.FeatureClassWrap;
if (featureClassWrap.IsUse)
{
flag = true;
IDataset featureClass = featureClassWrap.FeatureClass as IDataset;
esriNetworkLoaderFeatureClassCheck _esriNetworkLoaderFeatureClassCheck =
preserveEnabledValues.CanUseFeatureClass(featureClass.Name);
esriNetworkLoaderFeatureClassCheck _esriNetworkLoaderFeatureClassCheck1 =
_esriNetworkLoaderFeatureClassCheck;
if (_esriNetworkLoaderFeatureClassCheck1 ==
esriNetworkLoaderFeatureClassCheck.esriNLFCCUnknownError)
{
MessageBox.Show(string.Concat(featureClass.Name, " 未知错误"));
flag = false;
}
else
{
switch (_esriNetworkLoaderFeatureClassCheck1)
{
case esriNetworkLoaderFeatureClassCheck.esriNLFCCInTerrain:
{
MessageBox.Show(string.Concat(featureClass.Name, "已用在三角网中"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCIsCompressedReadOnly:
{
MessageBox.Show(string.Concat(featureClass.Name, "是压缩只读要素类"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCInTopology:
{
MessageBox.Show(string.Concat(featureClass.Name, "已用在拓扑中"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCRegisteredAsVersioned:
{
MessageBox.Show(string.Concat(featureClass.Name, "已注册版本"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCInvalidShapeType:
{
MessageBox.Show(string.Concat(featureClass.Name, "不是点或线几何要素"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCInvalidFeatureType:
{
MessageBox.Show(string.Concat(featureClass.Name, "是无效要素类型"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCInAnotherNetwork:
{
MessageBox.Show(string.Concat(featureClass.Name, "已在其它网络中使用"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCCannotOpen:
{
MessageBox.Show(string.Concat("无法打开", featureClass.Name));
flag = false;
break;
}
}
}
if (flag &&
_esriNetworkLoaderFeatureClassCheck == esriNetworkLoaderFeatureClassCheck.esriNLFCCValid)
{
preserveEnabledValues.PreserveEnabledValues = this.PreserveEnabledValues;
esriNetworkLoaderFieldCheck _esriNetworkLoaderFieldCheck =
preserveEnabledValues.CheckEnabledDisabledField(featureClass.Name,
networkLoaderProp.DefaultEnabledField);
if (_esriNetworkLoaderFieldCheck == esriNetworkLoaderFieldCheck.esriNLFCUnknownError)
{
MessageBox.Show(string.Concat(featureClass.Name, ": (ENABLED 字段)- 产生未知错误."));
flag = false;
}
else
{
switch (_esriNetworkLoaderFieldCheck)
{
case esriNetworkLoaderFieldCheck.esriNLFCInvalidDomain:
{
MessageBox.Show(string.Concat(featureClass.Name, ": ENABLED字段有无效域值."));
flag = false;
break;
}
case esriNetworkLoaderFieldCheck.esriNLFCInvalidType:
{
MessageBox.Show(string.Concat(featureClass.Name, ": ENABLED字段有无效类型"));
flag = false;
break;
}
case esriNetworkLoaderFieldCheck.esriNLFCNotFound:
{
try
{
networkLoader.PutEnabledDisabledFieldName(featureClass.Name,
networkLoaderProp.DefaultEnabledField);
break;
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
break;
}
break;
}
}
}
if (flag)
{
esriNetworkClassAncillaryRole _esriNetworkClassAncillaryRole =
esriNetworkClassAncillaryRole.esriNCARNone;
if (featureClassWrap.GeometryType == esriGeometryType.esriGeometryPoint &&
featureClassWrap.IsUse)
{
_esriNetworkClassAncillaryRole = esriNetworkClassAncillaryRole.esriNCARSourceSink;
}
esriFeatureType featureType = featureClassWrap.FeatureType;
if (featureType == esriFeatureType.esriFTSimpleJunction)
{
switch (_esriNetworkClassAncillaryRole)
{
case esriNetworkClassAncillaryRole.esriNCARNone:
{
break;
}
case esriNetworkClassAncillaryRole.esriNCARSourceSink:
{
_esriNetworkLoaderFieldCheck =
preserveEnabledValues.CheckAncillaryRoleField(featureClass.Name,
networkLoaderProp.DefaultAncillaryRoleField);
if (_esriNetworkLoaderFieldCheck ==
esriNetworkLoaderFieldCheck.esriNLFCUnknownError)
{
MessageBox.Show(string.Concat(featureClass.Name,
": (ROLE Field)- An unknown error was encountered."));
geometricNetworkByName = null;
return(geometricNetworkByName);
}
else
{
switch (_esriNetworkLoaderFieldCheck)
{
case esriNetworkLoaderFieldCheck.esriNLFCInvalidDomain:
{
MessageBox.Show(string.Concat(featureClass.Name,
": ROLE字段有无效域值."));
geometricNetworkByName = null;
return(geometricNetworkByName);
}
case esriNetworkLoaderFieldCheck.esriNLFCInvalidType:
{
MessageBox.Show(string.Concat(featureClass.Name,
": ROLE字段有无效类型."));
geometricNetworkByName = null;
return(geometricNetworkByName);
}
case esriNetworkLoaderFieldCheck.esriNLFCNotFound:
{
try
{
networkLoader.PutAncillaryRole(featureClass.Name,
esriNetworkClassAncillaryRole.esriNCARSourceSink,
networkLoaderProp.DefaultAncillaryRoleField);
break;
}
catch
{
break;
}
break;
}
default:
{
break;
}
}
}
break;
}
default:
{
goto case esriNetworkClassAncillaryRole.esriNCARNone;
}
}
}
try
{
switch (featureType)
{
case esriFeatureType.esriFTSimpleJunction:
{
networkLoader.AddFeatureClass(featureClass.Name,
esriFeatureType.esriFTSimpleJunction, gUIDSIMPLEJUNCTIONCLSID,
(this.IsSnap ? featureClassWrap.canChangeGeometry : false));
goto case esriFeatureType.esriFTComplexJunction;
}
case esriFeatureType.esriFTSimpleEdge:
{
networkLoader.AddFeatureClass(featureClass.Name,
esriFeatureType.esriFTSimpleEdge, gUIDSIMPLEEDGECLSID,
(this.IsSnap ? featureClassWrap.canChangeGeometry : false));
goto case esriFeatureType.esriFTComplexJunction;
}
case esriFeatureType.esriFTComplexJunction:
{
flag1 = true;
break;
}
case esriFeatureType.esriFTComplexEdge:
{
networkLoader.AddFeatureClass(featureClass.Name,
esriFeatureType.esriFTComplexEdge, uIDClass,
(this.IsSnap ? featureClassWrap.canChangeGeometry : false));
goto case esriFeatureType.esriFTComplexJunction;
}
default:
{
goto case esriFeatureType.esriFTComplexJunction;
}
}
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
if (cOMException.ErrorCode != -2147220462)
{
MessageBox.Show(cOMException.Message);
}
else
{
MessageBox.Show(string.Concat("要素类[", featureClass.Name, "]无法添加到几何网络中!"));
}
}
catch (Exception exception1)
{
MessageBox.Show(exception1.Message);
}
}
}
}
}
if (flag1)
{
for (i = 0; i < this.WeightAssociations.Count; i++)
{
BulidGeometryNetworkHelper.WeightAssociation weightAssociation =
this.WeightAssociations[i] as BulidGeometryNetworkHelper.WeightAssociation;
preserveEnabledValues.AddWeightAssociation(weightAssociation.networkWeightName,
weightAssociation.featureClassName, weightAssociation.fieldName);
}
preserveEnabledValues.ConfigurationKeyword = this.ConfigurationKeyword;
preserveEnabledValues.PreserveEnabledValues = this.PreserveEnabledValues;
networkLoader.LoadNetwork();
geometricNetworkByName = ifeatureDataset1.GeometricNetworkByName[this.Name];
}
else
{
geometricNetworkByName = null;
}
}
catch (Exception exception2)
{
MessageBox.Show(exception2.Message);
geometricNetworkByName = null;
return(geometricNetworkByName);
}
return(geometricNetworkByName);
}
public static IFeatureClass CreateFeatureClass(object objectWorkspace, string name, ISpatialReference spatialReference, esriFeatureType featureType, esriGeometryType geometryType, IFields fields, UID uidCLSID, UID uidCLSEXT, string configWord)
{
// Check for invalid parameters.
if (objectWorkspace == null)
{
throw new ArgumentNullException("[objectWorkspace] cannot be null");
}
if (!((objectWorkspace is IFeatureWorkspace) || (objectWorkspace is IFeatureDataset)))
{
throw (new ArgumentNullException("[objectWorkspace] must be IFeatureWorkspace or IFeatureDataset"));
}
if (string.IsNullOrEmpty(name))
{
throw (new ArgumentNullException("[name] cannot be empty"));
}
if ((objectWorkspace is IWorkspace) && (spatialReference == null))
{
throw (new ArgumentNullException("[spatialReference] cannot be null for StandAlong FeatureClasses"));
}
// Set ClassID (if Null)
if (uidCLSID == null)
{
uidCLSID = new UIDClass();
switch (featureType)
{
case (esriFeatureType.esriFTSimple):
uidCLSID.Value = "{52353152-891A-11D0-BEC6-00805F7C4268}";
break;
case (esriFeatureType.esriFTSimpleJunction):
geometryType = esriGeometryType.esriGeometryPoint;
uidCLSID.Value = "{CEE8D6B8-55FE-11D1-AE55-0000F80372B4}";
break;
case (esriFeatureType.esriFTComplexJunction):
uidCLSID.Value = "{DF9D71F4-DA32-11D1-AEBA-0000F80372B4}";
break;
case (esriFeatureType.esriFTSimpleEdge):
geometryType = esriGeometryType.esriGeometryPolyline;
uidCLSID.Value = "{E7031C90-55FE-11D1-AE55-0000F80372B4}";
break;
case (esriFeatureType.esriFTComplexEdge):
geometryType = esriGeometryType.esriGeometryPolyline;
uidCLSID.Value = "{A30E8A2A-C50B-11D1-AEA9-0000F80372B4}";
break;
case (esriFeatureType.esriFTAnnotation):
geometryType = esriGeometryType.esriGeometryPolygon;
uidCLSID.Value = "{E3676993-C682-11D2-8A2A-006097AFF44E}";
break;
case (esriFeatureType.esriFTDimension):
geometryType = esriGeometryType.esriGeometryPolygon;
uidCLSID.Value = "{496764FC-E0C9-11D3-80CE-00C04F601565}";
break;
}
}
// Set uidCLSEXT (if Null)
if (uidCLSEXT == null)
{
switch (featureType)
{
case (esriFeatureType.esriFTAnnotation):
uidCLSEXT = new UIDClass();
uidCLSEXT.Value = "{24429589-D711-11D2-9F41-00C04F6BC6A5}";
break;
case (esriFeatureType.esriFTDimension):
uidCLSEXT = new UIDClass();
uidCLSEXT.Value = "{48F935E2-DA66-11D3-80CE-00C04F601565}";
break;
}
}
// Add Fields
if (fields == null)
{
// Create fields collection
fields = new FieldsClass();
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
// Create the geometry field
IGeometryDef geometryDef = new GeometryDefClass();
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
// Assign Geometry Definition
geometryDefEdit.GeometryType_2 = geometryType;
geometryDefEdit.GridCount_2 = 1;
geometryDefEdit.set_GridSize(0, 0.5);
geometryDefEdit.AvgNumPoints_2 = 2;
geometryDefEdit.HasM_2 = false;
geometryDefEdit.HasZ_2 = false;
if (objectWorkspace is IWorkspace)
{
// If this is a STANDALONE FeatureClass then add spatial reference.
geometryDefEdit.SpatialReference_2 = spatialReference;
}
// Create OID Field
IField fieldOID = new FieldClass();
IFieldEdit fieldEditOID = (IFieldEdit)fieldOID;
fieldEditOID.Name_2 = "OBJECTID";
fieldEditOID.AliasName_2 = "OBJECTID";
fieldEditOID.Type_2 = esriFieldType.esriFieldTypeOID;
fieldsEdit.AddField(fieldOID);
// Create Geometry Field
IField fieldShape = new FieldClass();
IFieldEdit fieldEditShape = (IFieldEdit)fieldShape;
fieldEditShape.Name_2 = "SHAPE";
fieldEditShape.AliasName_2 = "SHAPE";
fieldEditShape.Type_2 = esriFieldType.esriFieldTypeGeometry;
fieldEditShape.GeometryDef_2 = geometryDef;
fieldsEdit.AddField(fieldShape);
}
// Locate Shape Field
string stringShapeFieldName = null;
int i = 0;
while (i <= fields.FieldCount - 1)
{
if (fields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
stringShapeFieldName = fields.get_Field(i).Name;
break;
}
i = i + 1;
}
if (stringShapeFieldName == null)
{
throw (new System.Data.ConstraintException("Cannot locate geometry field in FIELDS"));
}
IFeatureClass featureClass = null;
if (objectWorkspace is IFeatureWorkspace)
{
// Create a STANDALONE FeatureClass
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)objectWorkspace;
featureClass = featureWorkspace.CreateFeatureClass(name, fields, uidCLSID, uidCLSEXT, featureType, stringShapeFieldName, configWord);
}
else if (objectWorkspace is IFeatureDataset)
{
IFeatureDataset featureDataset = (IFeatureDataset)objectWorkspace;
featureClass = featureDataset.CreateFeatureClass(name, fields, uidCLSID, uidCLSEXT, featureType, stringShapeFieldName, configWord);
}
// Set the alias
IClassSchemaEdit classSchemaEdit = (IClassSchemaEdit)featureClass;
classSchemaEdit.AlterAliasName(GeodatabaseUtil.GetUnQualifiedName(name));
// Return FeatureClass
return(featureClass);
}
public IFeatureClass CreateFeatureDatasetFeatureClass(IFeatureDataset featureDataset, String featureClassName, IFields fieldsCollection, esriFeatureType featureType, String shapeFieldName)
{
IFeatureClassDescription fcDesc = new FeatureClassDescriptionClass();
IObjectClassDescription ocDesc = (IObjectClassDescription)fcDesc;
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = featureDataset.Workspace;
fieldChecker.Validate(fieldsCollection, out enumFieldError, out validatedFields);
// The enumFieldError enumerator can be inspected at this point to determine
// which fields were modified during validation.
IFeatureClass featureClass = featureDataset.CreateFeatureClass(featureClassName, validatedFields, ocDesc.InstanceCLSID,
ocDesc.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDesc.ShapeFieldName, "");
return(featureClass);
}
public abstract bool CreateFeatureClass(string featureClassName, IFields fieldDefs, esriFeatureType featureType, string geomFieldName);
public static IFeatureClass CreateFeatureClass(object object_0, string string_0,
ISpatialReference ispatialReference_0, esriFeatureType esriFeatureType_0,
esriGeometryType esriGeometryType_0, IFields ifields_0, UID uid_0, UID uid_1, string string_1)
{
if (object_0 == null)
{
throw new Exception("[objectWorkspace] 不能为空");
}
if (!((object_0 is IWorkspace) || (object_0 is IFeatureDataset)))
{
throw new Exception("[objectWorkspace] 必须是IWorkspace或IFeatureDataset");
}
if (string_0 == "")
{
throw new Exception("[name] cannot be empty");
}
if ((object_0 is IWorkspace) && (ispatialReference_0 == null))
{
throw new Exception("[spatialReference] cannot be null for StandAlong FeatureClasses");
}
if (uid_0 == null)
{
uid_0 = new UID();
switch (esriFeatureType_0)
{
case esriFeatureType.esriFTSimple:
uid_0.Value = "{52353152-891A-11D0-BEC6-00805F7C4268}";
break;
case esriFeatureType.esriFTSimpleJunction:
esriGeometryType_0 = esriGeometryType.esriGeometryPoint;
uid_0.Value = "{CEE8D6B8-55FE-11D1-AE55-0000F80372B4}";
break;
case esriFeatureType.esriFTSimpleEdge:
esriGeometryType_0 = esriGeometryType.esriGeometryPolyline;
uid_0.Value = "{E7031C90-55FE-11D1-AE55-0000F80372B4}";
break;
case esriFeatureType.esriFTComplexJunction:
uid_0.Value = "{DF9D71F4-DA32-11D1-AEBA-0000F80372B4}";
break;
case esriFeatureType.esriFTComplexEdge:
esriGeometryType_0 = esriGeometryType.esriGeometryPolyline;
uid_0.Value = "{A30E8A2A-C50B-11D1-AEA9-0000F80372B4}";
break;
case esriFeatureType.esriFTAnnotation:
esriGeometryType_0 = esriGeometryType.esriGeometryPolygon;
uid_0.Value = "{E3676993-C682-11D2-8A2A-006097AFF44E}";
break;
case esriFeatureType.esriFTDimension:
esriGeometryType_0 = esriGeometryType.esriGeometryPolygon;
uid_0.Value = "{496764FC-E0C9-11D3-80CE-00C04F601565}";
break;
}
}
if (uid_1 == null)
{
switch (esriFeatureType_0)
{
case esriFeatureType.esriFTAnnotation:
uid_1 = new UID();
uid_1.Value = "{24429589-D711-11D2-9F41-00C04F6BC6A5}";
break;
case esriFeatureType.esriFTDimension:
uid_1 = new UID();
uid_1.Value = "{48F935E2-DA66-11D3-80CE-00C04F601565}";
break;
}
}
if (ifields_0 == null)
{
ifields_0 = new Fields();
IFieldsEdit edit = (IFieldsEdit)ifields_0;
IGeometryDef def = new GeometryDef();
IGeometryDefEdit edit2 = (IGeometryDefEdit)def;
edit2.GeometryType_2 = esriGeometryType_0;
edit2.GridCount_2 = 1;
edit2.set_GridSize(0, 8555.04939799);
edit2.AvgNumPoints_2 = 2;
edit2.HasM_2 = false;
edit2.HasZ_2 = false;
if (object_0 is IWorkspace)
{
edit2.SpatialReference_2 = ispatialReference_0;
}
IField field = new Field();
IFieldEdit edit3 = (IFieldEdit)field;
edit3.Name_2 = "OBJECTID";
edit3.AliasName_2 = "OBJECTID";
edit3.Type_2 = esriFieldType.esriFieldTypeOID;
edit.AddField(field);
IField field2 = new Field();
IFieldEdit edit4 = (IFieldEdit)field2;
edit4.Name_2 = "SHAPE";
edit4.AliasName_2 = "SHAPE";
edit4.Type_2 = esriFieldType.esriFieldTypeGeometry;
edit4.GeometryDef_2 = def;
edit.AddField(field2);
}
string shapeFieldName = "";
for (int i = 0; i <= (ifields_0.FieldCount - 1); i++)
{
if (ifields_0.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
shapeFieldName = ifields_0.get_Field(i).Name;
break;
}
}
if (shapeFieldName == "")
{
throw new Exception("Cannot locate geometry field in FIELDS");
}
IFeatureClass class2 = null;
if (object_0 is IWorkspace)
{
IWorkspace workspace = (IWorkspace)object_0;
IFeatureWorkspace workspace2 = (IFeatureWorkspace)workspace;
return(workspace2.CreateFeatureClass(string_0, ifields_0, uid_0, uid_1, esriFeatureType_0,
shapeFieldName, string_1));
}
if (object_0 is IFeatureDataset)
{
class2 = ((IFeatureDataset)object_0).CreateFeatureClass(string_0, ifields_0, uid_0, uid_1,
esriFeatureType_0, shapeFieldName, string_1);
}
return(class2);
}
public static FeatureClass CreateFeatureClass(esriFeatureType featureType) {
return Factory.CreateFeatureClass(featureType, esriGeometryType.esriGeometryNull);
}
public FeatureClass(FeatureClass prototype) : base(prototype) {
this._featureType = prototype.FeatureType;
this._shapeType = prototype.ShapeType;
this._shapeFieldName = prototype.ShapeFieldName;
this._hasM = prototype.HasM;
this._hasZ = prototype.HasZ;
this._areaFieldName = prototype.AreaFieldName;
this._lengthFieldName = prototype.LengthFieldName;
if (prototype.Extent != null) {
this._extent = prototype.Extent.Clone() as Extent;
}
if (prototype.SpatialReference != null) {
this._spatialReference = prototype.SpatialReference.Clone() as SpatialReference;
}
}
public static FeatureClass CreateFeatureClass(esriFeatureType featureType, esriGeometryType geometryType) {
XPathNodeIterator iterator = null;
switch (featureType) {
case esriFeatureType.esriFTSimple:
switch (geometryType) {
case esriGeometryType.esriGeometryMultiPatch:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_MULTIPATCH, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
case esriGeometryType.esriGeometryPoint:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_POINT, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
case esriGeometryType.esriGeometryPolygon:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_POLYGON, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
case esriGeometryType.esriGeometryPolyline:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_POLYLINE, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
}
break;
case esriFeatureType.esriFTAnnotation:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_ANNOTATION, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
case esriFeatureType.esriFTDimension:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_DIMENSION, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
}
if (iterator == null) { return null; }
if (!iterator.MoveNext()) { return null; }
XPathNavigator navigator = iterator.Current;
FeatureClass featureClass = new FeatureClass(navigator); ;
return featureClass;
}
//
// CONSTRUCTOR
//
public FeatureClass(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <FeatureType>
XPathNavigator navigatorFeatureType = navigator.SelectSingleNode("FeatureType");
if (navigatorFeatureType != null) {
string featureType = navigatorFeatureType.Value;
this._featureType = (esriFeatureType)Enum.Parse(typeof(esriFeatureType), featureType, true);
}
// <ShapeType>
XPathNavigator navigatorShapeType = navigator.SelectSingleNode("ShapeType");
if (navigatorShapeType != null) {
string shapeType = navigatorShapeType.Value;
this._shapeType = (esriGeometryType)Enum.Parse(typeof(esriGeometryType), shapeType, true);
}
// <ShapeFieldName>
XPathNavigator navigatorShapeFieldName = navigator.SelectSingleNode("ShapeFieldName");
if (navigatorShapeFieldName != null) {
this._shapeFieldName = navigatorShapeFieldName.Value;
}
// <HasM>
XPathNavigator navigatorHasM = navigator.SelectSingleNode("HasM");
if (navigatorHasM != null) {
this._hasM = navigatorHasM.ValueAsBoolean;
}
// <HasZ>
XPathNavigator navigatorHasZ = navigator.SelectSingleNode("HasZ");
if (navigatorHasZ != null) {
this._hasZ = navigatorHasZ.ValueAsBoolean;
}
// <AreaFieldName>
XPathNavigator navigatorAreaFieldName = navigator.SelectSingleNode("AreaFieldName");
if (navigatorAreaFieldName != null) {
this._areaFieldName = navigatorAreaFieldName.Value;
}
// <LengthFieldName>
XPathNavigator navigatorLengthFieldName = navigator.SelectSingleNode("LengthFieldName");
if (navigatorLengthFieldName != null) {
this._lengthFieldName = navigatorLengthFieldName.Value;
}
// <Extent>
XPathNavigator navigatorExtent = navigator.SelectSingleNode("Extent");
if (navigatorExtent != null) {
this._extent = new Extent(navigatorExtent);
}
else {
this._extent = new Extent();
}
// <SpatialReference>
XPathNavigator navigatorSpatialReference = navigator.SelectSingleNode("SpatialReference");
if (navigatorSpatialReference != null) {
this._spatialReference = new SpatialReference(navigatorSpatialReference);
}
else {
this._spatialReference = new SpatialReference();
}
}
//---------------------------------------------------------------------
/// <summary>
/// Creates a new feature class. Returns the feature class or null if not successful. Throws but does not handle errors.
/// </summary>
/// <param name="sFeatName">Feature class name.</param>
/// <param name="configWord">Configuration keywords for the new feature class.</param>
/// <param name="oWorkspace">Workspace in which to create the new feature class.</param>
/// <param name="theFields">Fields collection of the new feature class.</param>
/// <param name="featureType">Feature type of the new feature class.</param>
/// <param name="geometryType">geometry type of the new feature class.</param>
/// <param name="CLSID">Class ID of the new feature class. May be null if featureType is not null.</param>
/// <param name="CLSEXT">Class extension ID of the new feature class. Pass null if none.</param>
/// <returns>Returns the cloned feature class. Throws an error if no feature class can be created.</returns>
private IFeatureClass CreateFeatureClass(string featureClassName, string configWord, object outWorkspace,
IFields fields, esriFeatureType featureType, esriGeometryType geometryType, UID CLSID, UID CLSEXT)
{
IFeatureClass featureClass = null;
if (outWorkspace == null) throw (new Exception("Workspace cannot be null"));
if (!((outWorkspace is IWorkspace) || (outWorkspace is IFeatureDataset)))
throw (new Exception("Workspace must be IWorkspace or IFeatureDataset"));
if (featureClassName == "") throw (new Exception("Feature class name cannot be empty string"));
UID uidCLSID = new UIDClass();
if (CLSID == null)
{
switch (featureType)
{
case (esriFeatureType.esriFTSimple):
uidCLSID.Value = "{52353152-891A-11D0-BEC6-00805F7C4268}";
break;
case (esriFeatureType.esriFTSimpleJunction):
geometryType = esriGeometryType.esriGeometryPoint;
uidCLSID.Value = "{CEE8D6B8-55FE-11D1-AE55-0000F80372B4}";
break;
case (esriFeatureType.esriFTComplexJunction):
uidCLSID.Value = "{DF9D71F4-DA32-11D1-AEBA-0000F80372B4}";
break;
case (esriFeatureType.esriFTSimpleEdge):
geometryType = esriGeometryType.esriGeometryPolyline;
uidCLSID.Value = "{E7031C90-55FE-11D1-AE55-0000F80372B4}";
break;
case (esriFeatureType.esriFTComplexEdge):
geometryType = esriGeometryType.esriGeometryPolyline;
uidCLSID.Value = "{A30E8A2A-C50B-11D1-AEA9-0000F80372B4}";
break;
case (esriFeatureType.esriFTAnnotation):
geometryType = esriGeometryType.esriGeometryPolygon;
uidCLSID.Value = "{E3676993-C682-11D2-8A2A-006097AFF44E}";
break;
case (esriFeatureType.esriFTDimension):
geometryType = esriGeometryType.esriGeometryPolygon;
uidCLSID.Value = "{496764FC-E0C9-11D3-80CE-00C04F601565}";
break;
}
}
else
{
uidCLSID = CLSID;
}
UID uidCLSEXT = new UIDClass();
if (CLSEXT == null)
{
switch (featureType)
{
case (esriFeatureType.esriFTAnnotation):
uidCLSEXT.Value = "{24429589-D711-11D2-9F41-00C04F6BC6A5}";
break;
case (esriFeatureType.esriFTDimension):
uidCLSEXT.Value = "{48F935E2-DA66-11D3-80CE-00C04F601565}";
break;
default:
uidCLSEXT = null;
break;
}
}
else
uidCLSEXT = CLSEXT;
string shapeFieldName = "";
for (int i = 0; i <= fields.FieldCount - 1; i++)
{
if (fields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
shapeFieldName = fields.get_Field(i).Name;
break;
}
}
if (shapeFieldName == "") throw new Exception("Cannot locate geometry field");
if (outWorkspace is IWorkspace)
{
IWorkspace workspace = (IWorkspace)outWorkspace;
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
featureClass = featureWorkspace.CreateFeatureClass(featureClassName, fields, uidCLSID, uidCLSEXT,
featureType, shapeFieldName, configWord);
}
else if (outWorkspace is IFeatureDataset)
{
IFeatureDataset featureDataset = (IFeatureDataset)outWorkspace;
featureClass = featureDataset.CreateFeatureClass(featureClassName, fields, uidCLSID, uidCLSEXT,
featureType, shapeFieldName, configWord);
}
return featureClass;
}
private IFeatureClass CreateFeatureClass(IFeatureWorkspace FeatureWorkspace, string LayerName, esriFeatureType featureType, esriGeometryType GeometryType)
{
IFields fields = new FieldsClass();
IFieldsEdit edit = fields as IFieldsEdit;
//创建OBJECTID字段
IField field3 = new FieldClass();
IFieldEdit edit2 = field3 as IFieldEdit;
edit2.Name_2 = "OBJECTID";
edit2.AliasName_2 = "OBJECTID";
edit2.Type_2 = esriFieldType.esriFieldTypeOID;
edit.AddField(field3);
//创建Shape字段
IGeometryDef def = new GeometryDefClass();
IGeometryDefEdit edit4 = def as IGeometryDefEdit;
edit4.GeometryType_2 = GeometryType;
edit4.GridCount_2 = 1;
edit4.set_GridSize(0, 1000);
edit4.AvgNumPoints_2 = 2;
edit4.HasM_2 = false;
edit4.HasZ_2 = false;
edit4.SpatialReference_2 = this.ExportSpatialReference;
IField field4 = new FieldClass();
IFieldEdit edit3 = field4 as IFieldEdit;
edit3.Name_2 = "SHAPE";
edit3.AliasName_2 = "SHAPE";
edit3.Type_2 = esriFieldType.esriFieldTypeGeometry;
edit3.GeometryDef_2 = def;
edit.AddField(field4);
string ShapeFiledName = field4.Name;
UID uid = null;
UID uid2 = null;
switch (featureType)
{
case esriFeatureType.esriFTSimple: //FeatureClass
IObjectClassDescription description4 = new FeatureClassDescriptionClass();
uid = description4.InstanceCLSID;
uid2 = description4.ClassExtensionCLSID;
break;
case esriFeatureType.esriFTAnnotation: //AnnotationFeatureClass
IObjectClassDescription description = new AnnotationFeatureClassDescriptionClass();
uid = description.InstanceCLSID;
uid2 = description.ClassExtensionCLSID;
GeometryType = esriGeometryType.esriGeometryPolygon;
break;
}
//创建要素对象
IFeatureClass fc = FeatureWorkspace.CreateFeatureClass(LayerName, fields, uid, uid2, featureType, ShapeFiledName, null);
return(fc);
}
