private void cbFields_SelectionChangeCommitted(object sender, EventArgs e)
{
var selectItem = cbFields.SelectedItem;
if (selectItem == null)
{
return;
}
string fieldName = selectItem.ToString();
ITable pTable = (ITable)pFc;
currentFieldType = pTable.Fields.Field[pTable.Fields.FindField(fieldName)].Type;
ICursor pCursor = pTable.Search(null, true);
IRow pRow = pCursor.NextRow();
HashSet <string> hsFieldValues = new HashSet <string>();
while (pRow != null)
{
object value = pRow.get_Value(pRow.Fields.FindField(fieldName));
if (value != null)
{
hsFieldValues.Add(value.ToString());
}
pRow = pCursor.NextRow();
}
string[] arrayFieldValues = hsFieldValues.ToArray();
cbFieldValues.Properties.Items.Clear();
for (int i = 0; i < arrayFieldValues.Length; i++)
{
//CheckedListBoxItem item = new CheckedListBoxItem();
cbFieldValues.Properties.Items.Add(arrayFieldValues[i], arrayFieldValues[i]);
}
}
public DomainFieldAttribute(string fieldName, esriFieldType fieldType, int position, string domainName,
esriDomainType domainType)
: base(fieldName, fieldType, position)
{
DomainName = domainName;
DomainType = domainType;
}
public static bool ConvertFromFieldType <T>(esriFieldType fieldType,
object value,
out T result,
out string message)
{
message = string.Empty;
if (value == DBNull.Value)
{
result = (T)System.Convert.ChangeType(DefaultValueEsriDataTypes[fieldType].Invoke(), typeof(T));
return(true);
}
try
{
result = (T)System.Convert.ChangeType(GdbFieldsTypes[fieldType].Invoke(value), typeof(T));
}
catch
{
message = $"Cannot convert {value} to {typeof(T)}";
result = default(T);
return(false);
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="field"></param>
/// <param name="fieldName"></param>
/// <param name="fieldType">See valid values at <see cref="ToEsriFieldType(string)"/></param>
/// <param name="width"></param>
/// <param name="precision"></param>
/// <param name="nullable"></param>
/// <param name="defaultValue"></param>
/// <param name="aliasName"></param>
/// <returns></returns>
public static IField SetField(IField field, string fieldName, string fieldType, int width = -1, int precision = -1, bool nullable = true, object defaultValue = null, string aliasName = null)
{
esriFieldType esriFieldType = TypeUtil.ToEsriFieldType(fieldType);
SetField(field, fieldName, esriFieldType, width, precision, nullable, defaultValue, aliasName);
return(field);
}
/// <summary>
/// 获取Field的类型，并按规定内容显示
/// </summary>
/// <param name="fieldTpye"></param>
/// <returns></returns>
private string GetFieldType(esriFieldType fieldTpye)
{
string type = null;
switch (fieldTpye)
{
case esriFieldType.esriFieldTypeBlob:
type = "Blob";
break;
case esriFieldType.esriFieldTypeDate:
type = "Data";
break;
case esriFieldType.esriFieldTypeDouble:
type = "Double";
break;
case esriFieldType.esriFieldTypeGeometry:
type = GetGeometryType();
break;
case esriFieldType.esriFieldTypeGlobalID:
type = "GlobalID";
break;
case esriFieldType.esriFieldTypeGUID:
type = "GUID";
break;
case esriFieldType.esriFieldTypeInteger:
type = "Integer";
break;
case esriFieldType.esriFieldTypeOID:
type = "ObjectID";
break;
case esriFieldType.esriFieldTypeRaster:
type = "Raster";
break;
case esriFieldType.esriFieldTypeSingle:
type = "Single";
break;
case esriFieldType.esriFieldTypeSmallInteger:
type = "SmallInteger";
break;
case esriFieldType.esriFieldTypeString:
type = "Text";
break;
case esriFieldType.esriFieldTypeXML:
type = "XML";
break;
}
return(type);
}
private void cmbSampleFeatureClass_SelectedIndexChanged(object sender, EventArgs e)
{
string cmbTxt = cmbSampleFeatureClass.Text;
if (cmbTxt == null || cmbTxt == "")
{
return;
}
ITable ftrCls = ftrDic[cmbTxt];
flds = ftrCls.Fields;
cmbDependent.Text = "";
cmbIndependent.Text = "";
cmbDependent.Items.Clear();
lstDependent.Items.Clear();
cmbIndependent.Items.Clear();
lstIndependent.Items.Clear();
for (int i = 0; i < flds.FieldCount; i++)
{
IField fld = flds.get_Field(i);
string fldNm = fld.Name;
esriFieldType fldType = fld.Type;
if (fldType != esriFieldType.esriFieldTypeBlob && fldType != esriFieldType.esriFieldTypeDate && fldType != esriFieldType.esriFieldTypeGeometry && fldType != esriFieldType.esriFieldTypeGlobalID && fldType != esriFieldType.esriFieldTypeXML && fldType != esriFieldType.esriFieldTypeGUID && fldType != esriFieldType.esriFieldTypeOID && fldType != esriFieldType.esriFieldTypeRaster)
{
cmbIndependent.Items.Add(fldNm);
if (fldType != esriFieldType.esriFieldTypeString)
{
cmbDependent.Items.Add(fldNm);
}
}
}
}
private static bool IsSupportedCompareFieldType(esriFieldType fieldType)
{
switch (fieldType)
{
case esriFieldType.esriFieldTypeSmallInteger:
case esriFieldType.esriFieldTypeInteger:
case esriFieldType.esriFieldTypeSingle:
case esriFieldType.esriFieldTypeDouble:
case esriFieldType.esriFieldTypeString:
case esriFieldType.esriFieldTypeDate:
case esriFieldType.esriFieldTypeGUID:
case esriFieldType.esriFieldTypeXML:
return(true);
case esriFieldType.esriFieldTypeGeometry:
case esriFieldType.esriFieldTypeBlob:
case esriFieldType.esriFieldTypeRaster:
case esriFieldType.esriFieldTypeOID:
case esriFieldType.esriFieldTypeGlobalID:
return(false);
default:
throw new ArgumentOutOfRangeException(nameof(fieldType));
}
}
//将Row信息写到导出的excel中
private static void WriteRowToExcel(Microsoft.Office.Interop.Excel.Application pExcel, IRow pRow, int iRow)
{
if (pExcel == null)
{
return;
}
if (pRow == null)
{
return;
}
//写属性值
for (int i = 0; i < pRow.Fields.FieldCount; i++)
{
esriFieldType pType = pRow.Fields.get_Field(i).Type;
//Geometry字段单独处理
if (pType == esriFieldType.esriFieldTypeGeometry)
{
pExcel.Cells[iRow, i + 1] = "SHAPE";
}
else if (pType == esriFieldType.esriFieldTypeString)
{
pExcel.Cells[iRow, i + 1] = "'" + pRow.get_Value(i).ToString();
}
else
{
pExcel.Cells[iRow, i + 1] = pRow.get_Value(i).ToString();
}
}
}
private esriFieldType ConversionFieldType(string FieldType)
{
esriFieldType efd = esriFieldType.esriFieldTypeString;
switch (FieldType)
{
case "Short Integer": efd = esriFieldType.esriFieldTypeSmallInteger; break;
case "Long Integer": efd = esriFieldType.esriFieldTypeInteger; break;
case "Single-precision floating-point num": efd = esriFieldType.esriFieldTypeSingle; break;
case "Double-precision floating-point number": efd = esriFieldType.esriFieldTypeDouble; break;
case "Character string": efd = esriFieldType.esriFieldTypeString; break;
case "Date": efd = esriFieldType.esriFieldTypeDate; break;
case "Long Integer representing an object identifier": efd = esriFieldType.esriFieldTypeOID; break;
case "Geometry": efd = esriFieldType.esriFieldTypeGeometry; break;
case "Binary Large Object": efd = esriFieldType.esriFieldTypeBlob; break;
case "Raster": efd = esriFieldType.esriFieldTypeRaster; break;
case "Globally Unique Identifier": efd = esriFieldType.esriFieldTypeGUID; break;
case "Esri Global ID": efd = esriFieldType.esriFieldTypeGlobalID; break;
case "XML Document": efd = esriFieldType.esriFieldTypeXML; break;
}
return(efd);
}
/// <summary>
/// 转换字段
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static String ParseEsriField(esriFieldType type)
{
switch (type)
{
case esriFieldType.esriFieldTypeBlob:
return("System.String");
case esriFieldType.esriFieldTypeDouble:
return("System.Double");
case esriFieldType.esriFieldTypeDate:
return("System.Date");
case esriFieldType.esriFieldTypeGeometry:
return("System.String");
case esriFieldType.esriFieldTypeInteger:
return("System.Int32");
case esriFieldType.esriFieldTypeSmallInteger:
return("System.Int32");
case esriFieldType.esriFieldTypeSingle:
return("System.Int32");
default:
return("System.String");
}
}
/// <summary>
/// 根据英文获取字段类型
/// </summary>
/// <param name="fieldType">字段类型名</param>
/// <returns></returns>
public static esriFieldType GetFieldTypeByEnglish(string fieldType)
{
//默认字符串类型
esriFieldType fType = esriFieldType.esriFieldTypeString;
switch (fieldType)
{
case "SmallInteger":
fType = esriFieldType.esriFieldTypeSmallInteger;
break;
case "Integer":
fType = esriFieldType.esriFieldTypeInteger;
break;
case "Single":
fType = esriFieldType.esriFieldTypeSingle;
break;
case "Double":
fType = esriFieldType.esriFieldTypeDouble;
break;
case "String":
fType = esriFieldType.esriFieldTypeString;
break;
case "Date":
fType = esriFieldType.esriFieldTypeDate;
break;
}
return(fType);
}
public static void AddField(this IFields fields, string name, esriFieldType type)
{
IFieldEdit fe = new FieldClass();
fe.Name_2 = name;
fe.Type_2 = type;
((IFieldsEdit)fields).AddField((IField)fe);
}
private void cmbZoneRaster_SelectedIndexChanged(object sender, EventArgs e)
{
string zNm = cmbZoneRaster.Text;
if (rstDic.ContainsKey(zNm))
{
cmbZoneField.Items.Clear();
cmbZoneField.Text = "";
cmbZoneField.Visible = false;
lblZone.Visible = false;
}
else
{
IFeatureClass ftrCls = ftrDic[zNm];
IFields flds = ftrCls.Fields;
cmbZoneField.Items.Clear();
for (int i = 0; i < flds.FieldCount; i++)
{
IField fld = flds.get_Field(i);
esriFieldType fldType = fld.Type;
if (fldType == esriFieldType.esriFieldTypeInteger || fldType == esriFieldType.esriFieldTypeDouble || fldType == esriFieldType.esriFieldTypeSingle || fldType == esriFieldType.esriFieldTypeSmallInteger || fldType == esriFieldType.esriFieldTypeOID)
{
cmbZoneField.Items.Add(fld.Name);
}
}
cmbZoneField.SelectedItem = ftrCls.OIDFieldName;
cmbZoneField.Visible = true;
lblZone.Visible = true;
}
}
private void GetUniqueVal()
{
if (fteClss == null)
{
return;
}
this.ValueList.Items.Clear();
int fieldIndex = -1;
string fieldSel = this.fieldslistBox.SelectedItem.ToString();
for (int i = 0; i < fteClss.Fields.FieldCount; i++)
{
if (fteClss.Fields.get_Field(i).Name == fieldSel && !string.IsNullOrEmpty(fieldSel))
{
fieldIndex = i;
break;
}
}
if (fieldIndex == -1)
{
return;
}
fieldType = fteClss.Fields.get_Field(fieldIndex).Type;
IFeatureCursor pCursor = fteClss.Search(null, false);
IFeature pFeature = pCursor.NextFeature();
while (pFeature != null)
{
this.ValueList.Items.Add(pFeature.get_Value(fieldIndex));
pFeature = pCursor.NextFeature();
}
}
private bool IsFieldNumeriqueAndEditable(string fieldName, Schematic.ISchematicElementClass elementClass)
{
ITable table = (ITable)elementClass;
if (table == null)
{
return(false);
}
int index = table.FindField(fieldName);
if (index < 0)
{
return(false);
}
esriFieldType fieldType = table.Fields.get_Field(index).Type;
if (((fieldType == esriFieldType.esriFieldTypeDouble) || (fieldType == esriFieldType.esriFieldTypeInteger) || (fieldType == esriFieldType.esriFieldTypeSmallInteger)) && table.Fields.get_Field(index).Editable)
{
return(true);
}
return(false);
}
/// <summary>
/// 根据esri字段类型，判断sql语句查询是否需要''
/// </summary>
/// <param name="esriFldType"></param>
/// <returns>返回true,则说明是string型，需要''</returns>
private static bool GetTypeByEsriField(esriFieldType esriFldType)
{
bool bol = true;
switch (esriFldType)
{
case esriFieldType.esriFieldTypeOID:
case esriFieldType.esriFieldTypeInteger:
case esriFieldType.esriFieldTypeSingle:
case esriFieldType.esriFieldTypeDouble:
{
bol = false;
break;
}
case esriFieldType.esriFieldTypeString:
case esriFieldType.esriFieldTypeDate:
case esriFieldType.esriFieldTypeBlob:
{
bol = true;
break;
}
}
return(bol);
}
private esriFieldType getType()
{
esriFieldType type = esriFieldType.esriFieldTypeInteger;
switch (comboBox1.Text)
{
case " Double":
type = esriFieldType.esriFieldTypeDouble;
break;
case "Geometry":
type = esriFieldType.esriFieldTypeGeometry;
break;
case "GUID":
type = esriFieldType.esriFieldTypeGUID;
break;
case "Int":
type = esriFieldType.esriFieldTypeInteger;
break;
case "OID":
type = esriFieldType.esriFieldTypeOID;
break;
case "String":
type = esriFieldType.esriFieldTypeString;
break;
default:
break;
}
return(type);
}
public void GetUniqueValues(ILayer ilayer_1, string string_1, ListBoxItemCollection listBoxItemCollection_0)
{
try
{
string str;
ITable table = this.method_2();
if ((string_1[0] == '\'') || (string_1[0] == '['))
{
str = string_1.Substring(1, string_1.Length - 2);
}
else
{
str = string_1;
}
ICursor cursor = table.Search(null, false);
IDataStatistics statistics = new DataStatisticsClass
{
Field = str,
Cursor = cursor
};
IEnumerator uniqueValues = statistics.UniqueValues;
uniqueValues.Reset();
int index = cursor.Fields.FindField(str);
esriFieldType type = cursor.Fields.get_Field(index).Type;
while (uniqueValues.MoveNext())
{
listBoxItemCollection_0.Add(this.ConvertFieldValueToString(type, uniqueValues.Current));
}
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
}
public PrimaryFieldAttribute(string fieldName, esriFieldType fieldType, int position)
: base(fieldName, fieldType, position)
{
NotNullable = true;
_isPrimary = true;
_isForeign = false;
}
private object method_12(esriFieldType esriFieldType_0)
{
switch (esriFieldType_0)
{
case esriFieldType.esriFieldTypeSmallInteger:
case esriFieldType.esriFieldTypeInteger:
case esriFieldType.esriFieldTypeSingle:
case esriFieldType.esriFieldTypeOID:
case esriFieldType.esriFieldTypeGlobalID:
return(0);
case esriFieldType.esriFieldTypeDouble:
return(0.0);
case esriFieldType.esriFieldTypeString:
case esriFieldType.esriFieldTypeGUID:
case esriFieldType.esriFieldTypeXML:
return(" ");
case esriFieldType.esriFieldTypeDate:
return("1900-1-1");
case esriFieldType.esriFieldTypeGeometry:
case esriFieldType.esriFieldTypeBlob:
case esriFieldType.esriFieldTypeRaster:
return(DBNull.Value);
}
return(DBNull.Value);
}
/// <summary>
/// 将type类型转换为esriFieldType
/// </summary>
/// <param name="pType"></param>
/// <returns></returns>
public static esriFieldType GetFieldType(Type pType)
{
esriFieldType fieldtype = esriFieldType.esriFieldTypeString;
string strType = pType.Name;
switch (strType.ToLower())
{
case "int32":
fieldtype = esriFieldType.esriFieldTypeInteger;
break;
case "string":
fieldtype = esriFieldType.esriFieldTypeString;
break;
case "double":
fieldtype = esriFieldType.esriFieldTypeDouble;
break;
case "float":
fieldtype = esriFieldType.esriFieldTypeSingle;
break;
default:
fieldtype = esriFieldType.esriFieldTypeString;
break;
}
return(fieldtype);
}
/// <summary>
/// 根据中文获取字段类型
/// </summary>
/// <param name="fieldType">字段类型名</param>
/// <returns></returns>
public static esriFieldType GetFieldTypeByChinese(string fieldType)
{
esriFieldType outType = esriFieldType.esriFieldTypeString;
switch (fieldType)
{
case "长整型":
outType = esriFieldType.esriFieldTypeInteger;
break;
case "短整型":
outType = esriFieldType.esriFieldTypeSmallInteger;
break;
case "浮点型":
outType = esriFieldType.esriFieldTypeSingle;
break;
case "双精度":
outType = esriFieldType.esriFieldTypeDouble;
break;
case "文本型":
outType = esriFieldType.esriFieldTypeString;
break;
case "日期型":
outType = esriFieldType.esriFieldTypeDate;
break;
}
return(outType);
}
/// <summary>
/// 添加新字段
/// </summary>
/// <param name="layer">图层</param>
/// <param name="fieldName">字段名称</param>
/// <param name="fieldType">字段类型</param>
/// <param name="isNullable"></param>
/// <param name="isRequired"></param>
/// <param name="isEditable"></param>
/// <returns></returns>
public bool AddNewField(ILayer layer, string fieldName, esriFieldType fieldType, bool isNullable = true,
bool isRequired = false, bool isEditable = true)
{
ITable iTable = AttributeTableClass.GetITableByLayer(layer);
return(AddNewField(iTable, fieldName, fieldType, isNullable, isRequired, isEditable));
}
public static ICodedValueDomain CreateCodedValueDomain(
[NotNull] string name,
esriFieldType fieldType,
params CodedValue[] values)
{
return(CreateCodedValueDomain(name, fieldType, null, values));
}
public PrimaryFieldAttribute(string fieldName, esriFieldType fieldType, int position)
: base(fieldName, fieldType, position)
{
NotNullable = true;
_isPrimary = true;
_isForeign = false;
}
/// <summary>
/// 向已有表格添加新字段，若字段存在则不添加，并返回字段索引
/// （注意，向已有表格添加字段使用IClass.AddFiled，而在创建表格时设置字段使用IFieldsEdit.AddField）
/// </summary>
/// <param name="table">操作的表格</param>
/// <param name="name">字段名</param>
/// <param name="aliasName">字段别名</param>
/// <param name="fieldType">字段类型</param>
/// <param name="length">字段长度，若为0则不设置长度（使用默认长度）</param>
/// <returns>添加的字段的索引</returns>
public static int AddField(this ITable table, string name, string aliasName, esriFieldType fieldType, int length = 0)
{
//若存在，则不需添加
int index = -1;
if ((index = table.Fields.FindField(name)) > -1)
{
return(index);
}
IField field = new FieldClass();
IFieldEdit fieldEdit = field as IFieldEdit;
fieldEdit.Name_2 = name;
fieldEdit.AliasName_2 = aliasName;
fieldEdit.Type_2 = fieldType;
if (length > 0)
{
fieldEdit.Length_2 = length;
}
IClass cls = table as IClass;
cls.AddField(fieldEdit); //此处使用IClass.AddFiled方法，不使用IFieldsEdit.AddField方法
return(cls.FindField(name));
}
/// <summary>
/// 将ArcGIS字段类型，转换成C#相应的数据类型
/// </summary>
/// <param name="fieldType">字段类型</param>
/// <returns></returns>
public static Type ParseFieldType(esriFieldType fieldType)
{
switch (fieldType)
{
case esriFieldType.esriFieldTypeSmallInteger:
return(typeof(int));
case esriFieldType.esriFieldTypeInteger:
return(typeof(long));
case esriFieldType.esriFieldTypeOID:
return(typeof(long));
case esriFieldType.esriFieldTypeSingle:
return(typeof(float));
case esriFieldType.esriFieldTypeDouble:
return(typeof(double));
case esriFieldType.esriFieldTypeGeometry:
return(typeof(IGeometry));
case esriFieldType.esriFieldTypeDate:
return(typeof(DateTime));
case esriFieldType.esriFieldTypeString:
case esriFieldType.esriFieldTypeGUID:
case esriFieldType.esriFieldTypeGlobalID:
case esriFieldType.esriFieldTypeXML:
default:
return(typeof(string));
}
}
/// <summary>
/// 检查某个字段是否符合类型
/// </summary>
/// <param name="pFeatureClass"></param>
/// <param name="fieldName"></param>
/// <param name="targetFieldType"></param>
/// <returns></returns>
public static bool FieldTypeCheck(this IFeatureClass pFeatureClass, string fieldName,
esriFieldType targetFieldType)
{
var type = pFeatureClass.Fields.Field[pFeatureClass.Fields.FindField(fieldName)].Type;
return(type == targetFieldType);
}
public static int AddField(IFeatureClass pFeatureClass, esriFieldType pesriFieldType, string pstrFieldName)
{
IFieldEdit pFieldEdit = GenerateFieldEdit(pesriFieldType, pstrFieldName);
pFeatureClass.AddField((IField)pFieldEdit);
return(pFeatureClass.Fields.FieldCount - 1);
}
public static IField CreateField(string fieldName, esriFieldType fieldType, int width = -1, int precision = -1, bool nullable = true, object defaultValue = null, string aliasName = null)
{
IField field = new FieldClass();
SetField(field, fieldName, fieldType, width, precision, nullable, defaultValue, aliasName);
return(field);
}
/// <summary>
///
/// </summary>
/// <param name="pFeatureClass"></param>
/// <param name="pesriFieldType"></param>
/// <param name="pstrFieldName"></param>
/// <param name="pobjEb"></param>
/// <remarks>the number of features in pFeatureClass and the count of pobjEb should be the same</remarks>
public static void AddFieldandAttribute(IFeatureClass pFeatureClass,
esriFieldType pesriFieldType, string pstrFieldName, IEnumerable <object> pobjEb)
{
var intIndex = TryAddField(pFeatureClass, pesriFieldType, pstrFieldName);
SetFieldValue(pFeatureClass, intIndex, pobjEb);
}
/// <summary>
/// Initializes a new instance of the <see cref="FieldMap"/> class.
/// </summary>
/// <param name="featureFieldname">The feature fieldname.</param>
/// <param name="fieldtype">The fieldtype.</param>
/// <param name="spatliteFieldName">Name of the spatlite field.</param>
/// <param name="dbtype">The dbtype.</param>
public FieldMap(string featureFieldname, esriFieldType fieldtype, string spatliteFieldName, DbType dbtype)
{
this.FeatureFieldname = featureFieldname;
this.SpatialiteFieldname = spatliteFieldName;
this.FieldType = fieldtype;
this.DBFieldType = dbtype;
}
private static CadField.CadFieldType GetCadFieldType(esriFieldType t)
{
CadField.CadFieldType result = CadField.CadFieldType.String;
if (t == esriFieldType.esriFieldTypeDouble)
{
result = CadField.CadFieldType.Double;
}
else if (t == esriFieldType.esriFieldTypeSingle)
{
result = CadField.CadFieldType.Double;
}
else if (t == esriFieldType.esriFieldTypeInteger)
{
result = CadField.CadFieldType.Integer;
}
else if (t == esriFieldType.esriFieldTypeOID)
{
result = CadField.CadFieldType.Integer;
}
else if (t == esriFieldType.esriFieldTypeSmallInteger)
{
result = CadField.CadFieldType.Short;
}
else if (t == esriFieldType.esriFieldTypeString)
{
result = CadField.CadFieldType.String;
}
return(result);
}
public static string ParseFieldType(esriFieldType TableFieldType)
{
switch (TableFieldType)
{
case esriFieldType.esriFieldTypeBlob:
return "System.String";
case esriFieldType.esriFieldTypeDate:
return "System.DateTime";
case esriFieldType.esriFieldTypeDouble:
return "System.Double";
case esriFieldType.esriFieldTypeGeometry:
return "System.String";
case esriFieldType.esriFieldTypeGlobalID:
return "System.String";
case esriFieldType.esriFieldTypeGUID:
return "System.String";
case esriFieldType.esriFieldTypeInteger:
return "System.Int32";
case esriFieldType.esriFieldTypeOID:
return "System.String";
case esriFieldType.esriFieldTypeRaster:
return "System.String";
case esriFieldType.esriFieldTypeSingle:
return "System.Single";
case esriFieldType.esriFieldTypeSmallInteger:
return "System.Int32";
case esriFieldType.esriFieldTypeString:
return "System.String";
default:
return "System.String";
}
}
public FieldAttribute(string fieldName, esriFieldType fieldType,int position)
{
FieldName = fieldName;
FieldType = fieldType;
_isPrimary = false;
_isForeign = false;
Index = position;
}
public RelationshipAttribute(Type classType, string foreignFieldName, esriFieldType fieldType)
: base(foreignFieldName, fieldType, -1)
{
ClassType = classType;
NotNullable = true;
_isPrimary = false;
_isForeign = true;
}
public void AddField(IFeatureClass pFeatureClass,string fieldName,esriFieldType fieldType)
{
//如果存在不必添加字段，直接返回
if (pFeatureClass.FieldExistCheck(fieldName)) return;
var pField = new FieldClass();
var pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = fieldName;
pFieldEdit.Type_2 = fieldType;
pFeatureClass.AddField(pFieldEdit);
}
public RelationshipClassFieldAttribute(string fieldName, string relationshipClass, string controllerNamespace,
esriFieldType fieldType, int position)
: base(fieldName, fieldType, position)
{
RelationshipClassName = relationshipClass;
ControllerNamespace = controllerNamespace;
_isPrimary = false;
_isForeign = true;
Cardinality = esriRelCardinality.esriRelCardinalityOneToMany;
}
//
// CONSTRUCTOR
//
public Domain(IXPathNavigable path) : base(path) {
// Suspect Events
this.SuspendEvents = true;
XPathNavigator navigator = path.CreateNavigator();
XPathNodeIterator iterator = navigator.SelectChildren(XPathNodeType.Element);
// <DomainName></DomainName>
XPathNavigator navigatorDomainName = navigator.SelectSingleNode(Xml.DOMAINNAME);
if (navigatorDomainName != null) {
this._name = navigatorDomainName.Value;
}
// <FieldType></FieldType>
XPathNavigator navigatorFieldType = navigator.SelectSingleNode(Xml.FIELDTYPE);
if (navigatorFieldType != null) {
this._fieldType = (esriFieldType)Enum.Parse(typeof(esriFieldType), navigatorFieldType.Value, true);
}
// <MergePolicy></MergePolicy>
XPathNavigator navigatorMergePolicy = navigator.SelectSingleNode(Xml.MERGEPOLICY);
if (navigatorMergePolicy != null) {
this._mergePolicy = (esriMergePolicyType)Enum.Parse(typeof(esriMergePolicyType), navigatorMergePolicy.Value, true);
}
// <SplitPolicy></SplitPolicy>
XPathNavigator navigatorSplitPolicy = navigator.SelectSingleNode(Xml.SPLITPOLICY);
if (navigatorSplitPolicy != null) {
this._splitPolicy = (esriSplitPolicyType)Enum.Parse(typeof(esriSplitPolicyType), navigatorSplitPolicy.Value, true);
}
// <Description></Description>
XPathNavigator navigatorDescription = navigator.SelectSingleNode(Xml.DESCRIPTION);
if (navigatorDescription != null) {
this._description = navigatorDescription.Value;
}
// <Owner></Owner>
XPathNavigator navigatorOwner = navigator.SelectSingleNode(Xml.OWNER);
if (navigatorOwner != null) {
this._owner = navigatorOwner.Value;
}
// Set Element
this.Refresh();
// Resume Events
this.SuspendEvents = false;
}
private static void AddField(IFeatureClass featureClass, string fieldName, esriFieldType fieldType)
{
IField newField = new FieldClass();
((IFieldEdit)newField).Name_2 = fieldName;
((IFieldEdit)newField).Type_2 = fieldType;
var schemaLock = (ISchemaLock)featureClass;
try
{
// Get an exclusive schema lock to change the schema.
schemaLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock);
featureClass.AddField(newField);
}
finally
{
//release the exclusive schema lock
schemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock);
}
}
public UniqueAttribute(string fieldName,esriFieldType fieldType,int fieldIndex)
: base(fieldName,fieldType,fieldIndex)
{
}
/// <summary>
/// 鉴于GP错误提示，可取以下值
/// TEXT | FLOAT | DOUBLE | SHORT | LONG | DATE | BLOB | RASTER | GUID
/// 那：
/// Geometry将取BLOB
/// OID将取LONG
/// XML将取TEXT
/// </summary>
/// <param name="fType"></param>
/// <returns></returns>
public static string GetFieldTypeGpString(esriFieldType fType)
{
switch (fType)
{
case esriFieldType.esriFieldTypeXML:
case esriFieldType.esriFieldTypeString:
return "TEXT";
case esriFieldType.esriFieldTypeSingle:
return "FLOAT";
case esriFieldType.esriFieldTypeDouble:
return "DOUBLE";
case esriFieldType.esriFieldTypeBlob:
return "BLOB";
case esriFieldType.esriFieldTypeDate:
return "DATE";
case esriFieldType.esriFieldTypeGeometry:
return "BLOB";
case esriFieldType.esriFieldTypeGUID:
return "GUID";
case esriFieldType.esriFieldTypeRaster:
return "Raster";
case esriFieldType.esriFieldTypeOID:
case esriFieldType.esriFieldTypeInteger:
return "LONG";
case esriFieldType.esriFieldTypeSmallInteger:
return "SHORT";
default:
return "TEXT";
}
}
private void AddSimpleField(IFieldsEdit fieldsEdit,esriFieldType type,string name,string aliasName)
{
IField field = new FieldClass();
IFieldEdit fieldEdit = field as IFieldEdit;
fieldEdit.Type_2 = type;
fieldEdit.Name_2 = name;
fieldEdit.AliasName_2 = aliasName;
fieldsEdit.AddField(field);
}
public static Type ParseType2System(esriFieldType type)
{
switch (type)
{
case esriFieldType.esriFieldTypeString:
return typeof(System.String);
case esriFieldType.esriFieldTypeInteger:
case esriFieldType.esriFieldTypeSmallInteger:
return typeof(System.Int32);
case esriFieldType.esriFieldTypeDouble:
case esriFieldType.esriFieldTypeSingle:
return typeof(System.Double);
default:
return typeof(System.String); ;
}
}
private IField createField(String fieldName, esriFieldType type)
{
IFieldEdit fe = new FieldClass();
fe.Name_2 = fieldName;
fe.Type_2 = type;
IField f = (IField)fe;
return f;
}
internal static bool AddAField(IFeatureClass pFeatureClass, string pFieldName, esriFieldType pFieldType, int pLength)
{
IField tField = new FieldClass();
IFieldEdit tFieldEdit = tField as IFieldEdit;
tFieldEdit.Type_2 = pFieldType;
tFieldEdit.Name_2 = pFieldName;
if (pFieldType == esriFieldType.esriFieldTypeString)
{
tFieldEdit.Length_2 = pLength;
}
ISchemaLock tSchemaLock = (ISchemaLock)pFeatureClass;
bool successful = false;
try
{
tSchemaLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock);
pFeatureClass.AddField(tField);
successful = true;
}
catch (Exception ex)
{
ServerLogger servLogger = new ServerLogger();
servLogger.LogMessage(ServerLogger.msgType.debug, "add field to output", 8000,
"Couldn't get schema lock to add field " + pFieldName + " to output!" + ex.Message);
}
finally
{
tSchemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock);
}
//logger.LogMessage(ServerLogger.msgType.debug, "AddAField", 99,
// "Added field: " + pFieldName+", success: "+successful.ToString());
return successful;
}
public BelongsToAttribute(Type foreignClass, string foreignFieldName,int parentValueFieldIndex, esriFieldType fieldType)
: base(foreignClass, foreignFieldName, fieldType)
{
ParentValueFieldIndex = parentValueFieldIndex;
}
/// <summary>
/// Creates the field collection for a new feature class or standalone table.
/// </summary>
/// <param name="bSpatial">True if the new fields collection is for a feature class, false if a table.</param>
/// <param name="bHasZ">True if the geometry field of the fields collection to be created is to be Z aware.</param>
/// <param name="bHasM">True if the geometry field of the fields collection to be created is to be M aware.</param>
/// <param name="oWorkspace">The workspace in which a new feature class will be created from the fields collection.</param>
/// <param name="geomType">The geometry type of the feature class to be created from the new fields collection.</param>
/// <param name="aFldLengths">An array of field lengths of the fields collection to be created.</param>
/// <param name="aFldNames">An array of field names of the fields collection to be created.</param>
/// <param name="aFldAliases">An array of field aliases of the fields collection to be created.</param>
/// <param name="aFldTypes">An array of field types of the fields collection to be created.</param>
/// <param name="spatialReference">The coordinate system to be assigned to the new feature class.</param>
/// <returns>Returns the new field collection. Throws an error if no field collection can be created.</returns>
private IFields CreateFieldsCollection(bool hasGeom, bool hasZ, bool hasM, object outWorkspace,
esriGeometryType geometryType, int[] fieldLengths, string[] fieldNames, string[] fieldAliases,
esriFieldType[] fieldTypes, bool[] fieldNullable, ISpatialReference spatialReference)
{
if ((hasGeom) && (outWorkspace is IWorkspace) && (spatialReference == null))
throw new Exception("Spatial reference must be defined for standalone feature classes");
IWorkspace outputWorkspace = null;
if (outWorkspace is IWorkspace)
{
outputWorkspace = outWorkspace as IWorkspace;
}
else if (outWorkspace is IFeatureDataset)
{
outputWorkspace = ((IDataset)((IFeatureDataset)outWorkspace)).Workspace;
}
IFields fields = new FieldsClass();
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
if (hasGeom)
{
IGeometryDef geometryDef = new GeometryDefClass();
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
geometryDefEdit.GeometryType_2 = geometryType;
geometryDefEdit.GridCount_2 = 1;
geometryDefEdit.set_GridSize(0, 0); // (0, 0.5);
geometryDefEdit.AvgNumPoints_2 = 2;
geometryDefEdit.HasM_2 = hasM;
geometryDefEdit.HasZ_2 = hasZ;
if (outWorkspace is IWorkspace) geometryDefEdit.SpatialReference_2 = spatialReference;
IField fieldOID = new FieldClass();
IFieldEdit fieldEditOID = (IFieldEdit)fieldOID;
fieldEditOID.Name_2 = "OBJECTID";
fieldEditOID.AliasName_2 = "OBJECTID";
fieldEditOID.Type_2 = esriFieldType.esriFieldTypeOID;
fieldsEdit.AddField(fieldOID);
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);
}
else
{
IField fieldOID = new FieldClass();
IFieldEdit fieldEditOID = (IFieldEdit)fieldOID;
fieldEditOID.Name_2 = "OBJECTID";
fieldEditOID.AliasName_2 = "OBJECTID";
fieldEditOID.Type_2 = esriFieldType.esriFieldTypeOID;
fieldsEdit.AddField(fieldOID);
}
if (fieldAliases == null) fieldAliases = fieldNames;
IField fieldAtt;
IFieldEdit fieldEditAtt;
for (int i = 0; i < fieldTypes.Length; i++)
{
if (String.IsNullOrEmpty(fieldNames[i]))
throw new Exception(String.Format("Error creating field {0}", i));
if ((fieldTypes[i] == esriFieldType.esriFieldTypeOID) ||
(fieldTypes[i] == esriFieldType.esriFieldTypeGeometry))
continue;
fieldAtt = new FieldClass();
fieldEditAtt = (IFieldEdit)fieldAtt;
fieldEditAtt.Name_2 = fieldNames[i];
if (!String.IsNullOrEmpty(fieldAliases[i]))
fieldEditAtt.AliasName_2 = fieldAliases[i];
fieldEditAtt.Type_2 = fieldTypes[i];
fieldEditAtt.Editable_2 = true;
fieldEditAtt.Required_2 = false;
fieldEditAtt.IsNullable_2 = fieldNullable[i];// true;
if (fieldTypes[i] == esriFieldType.esriFieldTypeString)
{
//if ((fieldLengths[i] == -1) || ((fieldLengths[i] > 0) && (fieldLengths[i] < 256)))
fieldEditAtt.Length_2 = fieldLengths[i];
//else
// fieldEditAtt.Length_2 = 255;
}
fieldsEdit.AddField(fieldAtt);
}
IFieldChecker fldChk = new FieldCheckerClass();
fldChk.ValidateWorkspace = outputWorkspace;
IFields outFields;
IEnumFieldError fieldErrors;
fldChk.Validate(fields, out fieldErrors, out outFields);
return outFields;
}
private void AppendProperty(string name, esriFieldType fieldType, int length, bool isNullable)
{
string csType;
string vbType;
string lengthText = null;
switch (fieldType)
{
case esriFieldType.esriFieldTypeString:
csType = "string";
vbType = "String";
lengthText = ", " + length;
break;
case esriFieldType.esriFieldTypeInteger:
csType = "int";
vbType = "Integer";
break;
case esriFieldType.esriFieldTypeSmallInteger:
csType = "short";
vbType = "Short";
break;
case esriFieldType.esriFieldTypeDouble:
csType = "double";
vbType = "Double";
break;
case esriFieldType.esriFieldTypeSingle:
csType = "float";
vbType = "Single";
break;
case esriFieldType.esriFieldTypeDate:
csType = "DateTime";
vbType = "DateTime";
break;
case esriFieldType.esriFieldTypeBlob:
csType = "byte[]";
vbType = "Byte()";
break;
case esriFieldType.esriFieldTypeGUID:
csType = "Guid";
vbType = "Guid";
break;
default:
return;
}
if (isNullable
&& fieldType != esriFieldType.esriFieldTypeString
&& fieldType != esriFieldType.esriFieldTypeBlob)
{
csType += "?";
vbType += "?";
}
var propertyName = Regex.Replace(name, @"\W", "_");
propertyName = _keywords.Contains(propertyName.ToLower()) ? propertyName + "_" : propertyName;
var indentation = _hasNamespace ? " " : "";
_cs.AppendFormat("\r\n{0} [MappedField(\"{1}\"{2})]\r\n{0} public virtual {3} {4} {{ get; set; }}\r\n", indentation, name, lengthText, csType, propertyName);
_vb.AppendFormat("\r\n{0} <MappedField(\"{1}\"{2})>\r\n{0} Public Overridable Property {4} As {3}\r\n", indentation, name, lengthText, vbType, propertyName);
}
public static bool IsValidateValue(esriFieldType fieldType, string value, out string message) {
if (string.IsNullOrEmpty(value)) {
message = "is null or empty";
return false;
}
switch (fieldType) {
case esriFieldType.esriFieldTypeSmallInteger:
short valueTest1;
bool validTest1 = short.TryParse(value, out valueTest1);
message = validTest1 ? string.Empty : string.Format("is not a valid small integer");
return validTest1;
case esriFieldType.esriFieldTypeInteger:
int valueTest2;
bool validTest2 = int.TryParse(value, out valueTest2);
message = validTest2 ? string.Empty : string.Format("is not a valid integer");
return validTest2;
case esriFieldType.esriFieldTypeSingle:
float valueTest3;
bool validTest3 = float.TryParse(value, out valueTest3);
message = validTest3 ? string.Empty : string.Format("is not a valid single/float");
return validTest3;
case esriFieldType.esriFieldTypeDouble:
double valueTest4;
bool validTest4 = double.TryParse(value, out valueTest4);
message = validTest4 ? string.Empty : string.Format("is not a valid double");
return validTest4;
case esriFieldType.esriFieldTypeString:
message = string.Empty;
return true;
case esriFieldType.esriFieldTypeDate:
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
DateTimeFormatInfo dateTimeFormatInfo = cultureInfo.DateTimeFormat;
DateTime valueTest5;
bool validTest5 = DateTime.TryParseExact(value, dateTimeFormatInfo.SortableDateTimePattern, cultureInfo, DateTimeStyles.None, out valueTest5);
message = validTest5 ? string.Empty : string.Format("is not a valid date");
return validTest5;
default:
message = string.Format("field type [{0}] does not support default values", fieldType.ToString());
return false;
}
}
public OneToOneAttribute(Type classType, string foreignFieldName, esriFieldType fieldType,int relatedAttributeIndex)
: base(classType, foreignFieldName, fieldType)
{
RelatedAttributeIndex = relatedAttributeIndex;
}
internal static String UnBuildDataType(esriFieldType theType, int theLength)
{
String retVal = "";
switch (theType)
{
case esriFieldType.esriFieldTypeGUID:
retVal = "GUID";
break;
case esriFieldType.esriFieldTypeInteger:
retVal = "Integer";
break;
case esriFieldType.esriFieldTypeSmallInteger:
retVal = "SmallInteger";
break;
case esriFieldType.esriFieldTypeSingle:
retVal = "Single";
break;
case esriFieldType.esriFieldTypeDouble:
retVal = "Double";
break;
case esriFieldType.esriFieldTypeString:
retVal = "String(" + theLength.ToString() + ")";
break;
case esriFieldType.esriFieldTypeDate:
retVal = "DateTime";
break;
}
return retVal;
}
internal static int getTransformNumber(esriFieldType srcDT, esriFieldType destDT)
{
switch (destDT)
{
case esriFieldType.esriFieldTypeString:
switch (srcDT)
{
case esriFieldType.esriFieldTypeInteger:
return 13;
break;
case esriFieldType.esriFieldTypeSingle:
return 12;
break;
case esriFieldType.esriFieldTypeDouble:
return 10;
break;
case esriFieldType.esriFieldTypeString:
return 0;
break;
case esriFieldType.esriFieldTypeDate:
return 14;
break;
default:
return -1;
break;
}
case esriFieldType.esriFieldTypeInteger:
switch (srcDT)
{
case esriFieldType.esriFieldTypeSingle:
return 4;
break;
case esriFieldType.esriFieldTypeDouble:
return 5;
break;
case esriFieldType.esriFieldTypeString:
return 6;
break;
case esriFieldType.esriFieldTypeDate:
return 7;
break;
case esriFieldType.esriFieldTypeInteger:
return 0;
break;
default:
return -1;
break;
}
break;
case esriFieldType.esriFieldTypeDouble:
switch (srcDT)
{
case esriFieldType.esriFieldTypeSmallInteger:
return 1;
break;
case esriFieldType.esriFieldTypeInteger:
return 3;
break;
case esriFieldType.esriFieldTypeString:
return 2;
break;
case esriFieldType.esriFieldTypeSingle:
return 0;
break;
case esriFieldType.esriFieldTypeDouble:
return 0;
break;
default:
return -1;
break;
}
break;
case esriFieldType.esriFieldTypeGUID:
switch (srcDT)
{
case esriFieldType.esriFieldTypeString:
return 16;
break;
case esriFieldType.esriFieldTypeGUID:
return 0;
break;
default:
return -1;
break;
}
default:
return -1;
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FieldPropertyDescriptor"/> class.
/// </summary>
/// <param name="wrappedTable">The wrapped table.</param>
/// <param name="fieldName">Name of the field within wrappedTable.</param>
/// <param name="fieldIndex">Index of the field within wrappedTable.</param>
public FieldPropertyDescriptor(ITable wrappedTable, string fieldName, int fieldIndex)
: base(fieldName, null)
{
wrappedFieldIndex = fieldIndex;
// Get the field this property will represent. We will use it to
// get the field type and determine whether it can be edited or not. In
// this case, editable means the field's editable property is true and it
// is not a blob, geometry or raster field.
IField wrappedField = wrappedTable.Fields.get_Field(fieldIndex);
esriType = wrappedField.Type;
isEditable = wrappedField.Editable &&
(esriType != esriFieldType.esriFieldTypeBlob) &&
(esriType != esriFieldType.esriFieldTypeRaster) &&
(esriType != esriFieldType.esriFieldTypeGeometry);
netType = actualType = EsriFieldTypeToSystemType(wrappedField);
wkspcEdit = ((IDataset)wrappedTable).Workspace as IWorkspaceEdit;
}
internal static void AddField(IFeatureClass featureClass, string name, esriFieldType type)
{
IFieldEdit field = new FieldClass();
field.Name_2 = name;
field.Type_2 = type;
featureClass.AddField(field);
}
/// <summary>
/// 将esri的字段类型转换为VCT格式的字段类型
/// </summary>
/// <param name="pEsriFieldType"></param>
/// <returns></returns>
private string GetVCTFieldType(esriFieldType pEsriFieldType)
{
string strType = "Varchar";
switch (pEsriFieldType)
{
case esriFieldType.esriFieldTypeBlob:
break;
case esriFieldType.esriFieldTypeDate:
strType = "Datetime";
break;
case esriFieldType.esriFieldTypeDouble:
strType = "Float";
break;
case esriFieldType.esriFieldTypeGUID:
break;
case esriFieldType.esriFieldTypeGeometry:
break;
case esriFieldType.esriFieldTypeGlobalID:
break;
case esriFieldType.esriFieldTypeInteger:
strType = "Int";
break;
case esriFieldType.esriFieldTypeOID:
strType = "Int";
break;
case esriFieldType.esriFieldTypeRaster:
break;
case esriFieldType.esriFieldTypeSingle:
strType = "Float";
break;
case esriFieldType.esriFieldTypeSmallInteger:
strType = "Int";
break;
case esriFieldType.esriFieldTypeString:
strType = "Char";
break;
case esriFieldType.esriFieldTypeXML:
break;
default:
break;
}
return strType;
}
/// <summary>
/// Create Field for RecordSet.
/// </summary>
/// <param name="name">Field name.</param>
/// <param name="fieldType">Field type.</param>
/// <param name="length">Field length.</param>
/// <returns>Field.</returns>
private Field _CreateField(string name, esriFieldType fieldType, int length)
{
Field field = new Field();
field.Name = name;
field.Type = fieldType;
field.Length = length;
return field;
}
private bool CheckForTableFields(IDETable inputTable, string[] fieldNames, esriFieldType[] fieldTypes,
IGPMessage gpMessage)
{
IFields fields = inputTable.Fields;
int fieldIndex;
for (int i = 0; i < fieldNames.Length; i++)
{
fieldIndex = fields.FindField(fieldNames[i]);
if (fieldIndex == -1)
{
gpMessage.Type = esriGPMessageType.esriGPMessageTypeError;
gpMessage.Description = "Field named " + fieldNames[i] + " not found.";
return false;
}
if (fields.get_Field(fieldIndex).Type != fieldTypes[i])
{
gpMessage.Type = esriGPMessageType.esriGPMessageTypeError;
gpMessage.Description = "Field named " + fieldNames[i] + " is not the expected type.";
return false;
}
}
return true;
}
private int numericDataType(esriFieldType theDT)
{
switch (theDT)
{
case esriFieldType.esriFieldTypeSmallInteger:
return 0;
break;
case esriFieldType.esriFieldTypeInteger:
return 1;
break;
case esriFieldType.esriFieldTypeSingle:
return 2;
break;
case esriFieldType.esriFieldTypeDouble:
return 3;
break;
case esriFieldType.esriFieldTypeString:
return 4;
break;
case esriFieldType.esriFieldTypeDate:
return 5;
break;
case esriFieldType.esriFieldTypeOID:
return 6;
break;
case esriFieldType.esriFieldTypeGUID:
return 10;
break;
case esriFieldType.esriFieldTypeGlobalID:
return 11;
break;
case esriFieldType.esriFieldTypeXML:
return 12;
break;
default:
return -1;
}
}
internal static bool AddAField(IFeatureClass pFeatureClass, string pFieldName, esriFieldType pFieldType)
{
bool successful = false;
if (pFieldType == esriFieldType.esriFieldTypeString)
{
throw new ArgumentException("Length must be specified for a new string field", "pFieldType");
}
else
{
successful = AddAField(pFeatureClass, pFieldName, pFieldType, 0);
}
return successful;
}
