public class FieldHelper
{
private static readonly Dictionary<string, esriFieldType> FieldTypes = new Dictionary<string, esriFieldType>
{
{"esriFieldTypeSmallInteger", esriFieldType.esriFieldTypeInteger},
{"esriFieldTypeInteger", esriFieldType.esriFieldTypeInteger},
{"esriFieldTypeSingle", esriFieldType.esriFieldTypeSingle},
{"esriFieldTypeDouble",esriFieldType.esriFieldTypeDouble},
{"esriFieldTypeString", esriFieldType.esriFieldTypeString},
{"esriFieldTypeDate",esriFieldType.esriFieldTypeDate},
{"esriFieldTypeOID", esriFieldType.esriFieldTypeOID},
{"esriFieldTypeGeometry", esriFieldType.esriFieldTypeGeometry},
{"esriFieldTypeBlob",esriFieldType.esriFieldTypeBlob},
{"esriFieldTypeRaster", esriFieldType.esriFieldTypeRaster},
{"esriFieldTypeGUID", esriFieldType.esriFieldTypeGUID},
{"esriFieldTypeGlobalID", esriFieldType.esriFieldTypeGlobalID},
{"esriFieldTypeXML", esriFieldType.esriFieldTypeXML}
};
/// <summary>
/// 根据ESRI字段类型获取.Net类型
/// </summary>
/// <param name="fieldType">ESRI字段类型</param>
/// <returns>.Net类型</returns>
public static Type GetTypeFromEsriFieldType(esriFieldType fieldType)
{
Type type = null;
switch (fieldType)
{
case esriFieldType.esriFieldTypeString:
type = Type.GetType("System.String");
break;
case esriFieldType.esriFieldTypeSingle:
type = Type.GetType("System.Single");
break;
case esriFieldType.esriFieldTypeSmallInteger:
type = Type.GetType("System.Int16");
break;
case esriFieldType.esriFieldTypeDate:
type = Type.GetType("System.DateTime");
break;
case esriFieldType.esriFieldTypeInteger:
case esriFieldType.esriFieldTypeOID:
type = Type.GetType("System.Int32");
break;
case esriFieldType.esriFieldTypeDouble:
type = Type.GetType("System.Double");
break;
default:
break;
}
return type;
}
/// <summary>
/// 判断字段可见性
/// </summary>
/// <param name="field"></param>
/// <param name="layerFields"></param>
/// <returns></returns>
public static bool VisibleField(IField field, ILayerFields layerFields)
{
if (layerFields == null) return true;
int index = layerFields.FindField(field.Name);
if (index < 0) return true;
IFieldInfo fieldInfo = layerFields.FieldInfo[index];
return fieldInfo.Visible;
}
/// <summary>
/// 设置图层字段可见性
/// </summary>
/// <param name="layerFields"></param>
/// <param name="hideFields"></param>
public static void SetVisibleField(ILayerFields layerFields, string[] hideFields)
{
if (layerFields == null || hideFields == null) return;
foreach (string field in hideFields)
{
int index = layerFields.FindField(field);
if (index >= 0)
layerFields.FieldInfo[index].Visible = false;
}
}
/// <summary>
/// 获取图层不可见的字段
/// </summary>
/// <param name="layerFields"></param>
/// <returns></returns>
public static IEnumerable<string> GetVisibleField(ILayerFields layerFields)
{
if (layerFields == null) return null;
List<string> listHideFields = new List<string>();
for (int i = 0; i < layerFields.FieldCount; i++)
{
IFieldInfo fieldInfo = layerFields.FieldInfo[i];
IField field = layerFields.Field[i];
if (!fieldInfo.Visible)
listHideFields.Add(field.Name);
}
return listHideFields.Count == 0 ? null : listHideFields;
}
/// <summary>
/// 获得图形shape字段
/// </summary>
/// <param name="pFields">字段集合</param>
/// <returns>图形shape字段</returns>
public static IField GetShapeField(IFields pFields)
{
if (pFields == null) return null;
for (int i = 0; i < pFields.FieldCount; i++)
{
if (pFields.Field[i].Type == esriFieldType.esriFieldTypeGeometry)
{
return pFields.Field[i];
}
}
return null;
}
/// <summary>
/// 获取创建要素类所需的最少字段
/// </summary>
/// <param name="type"></param>
/// <param name="spatialReference"></param>
/// <param name="hasM"></param>
/// <returns></returns>
public static IFields CreatedDefaultFields(esriGeometryType type, ISpatialReference spatialReference, bool hasM = false)
{
//创建IFeatureClassDescription接口
IFeatureClassDescription pFeaClassDesc = new FeatureClassDescriptionClass();
IObjectClassDescription pObjClassDesc = (IObjectClassDescription)pFeaClassDesc;
// 获取所需的字段集合
IFields pFields = pObjClassDesc.RequiredFields;
// 获取几何字段
int iShapeFieldIndex = pFields.FindField(pFeaClassDesc.ShapeFieldName);
IField pShapeField = pFields.Field[iShapeFieldIndex];
// 获取几何定义
IGeometryDef pGeometryDef = pShapeField.GeometryDef;
IGeometryDefEdit pGeometryDefEdit = (IGeometryDefEdit)pGeometryDef;
// 修改要素类的集合类型为线（默认为面）
pGeometryDefEdit.GeometryType_2 = type;
pGeometryDefEdit.HasM_2 = hasM;
pGeometryDefEdit.GridCount_2 = 1;
//设置格网大小为（0,0）
pGeometryDefEdit.set_GridSize(0, 0);
//设置坐标系
pGeometryDefEdit.SpatialReference_2 = spatialReference;
return pFields;
}
/// <summary>
/// 添加字段
/// </summary>
/// <param name="featureClass"></param>
/// <param name="field"></param>
public static void AddField(IFeatureClass featureClass, IField field)
{
ISchemaLock schemaLock = (ISchemaLock)featureClass;//创建模式锁对象
try
{
//修改为独占锁
schemaLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock);
//判断字段是否存在，存在则返回，不存在则添加
if (featureClass.FindField(field.Name) == -1)
{
// 添加字段
featureClass.AddField(field);
}
}
catch (Exception ex)
{
// 输出异常
Console.WriteLine(ex.Message);
}
finally
{
// 修改为共享锁
schemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock);
}
}
/// <summary>
/// 添加字段
/// </summary>
/// <param name="featureClass"></param>
/// <param name="field"></param>
public static void AddImField(IFeatureClass featureClass, IField field)
{
try
{
//判断字段是否存在，存在则返回，不存在则添加
if (featureClass.FindField(field.Name) == -1)
{
// 添加字段
featureClass.AddField(field);
}
}
catch (Exception)
{
}
}
/// <summary>
/// 验证字段
/// </summary>
/// <param name="workspace"></param>
/// <param name="fields"></param>
/// <returns></returns>
public static IFields ValidateFieldsForWorkspace(IWorkspace workspace, IFields fields)
{
// 创建IFieldChecker对象.
IFieldChecker pFieldChecker = new FieldCheckerClass();
pFieldChecker.ValidateWorkspace = workspace;
// 验证字段集
IEnumFieldError enumFieldError;
IFields validatedFields;
pFieldChecker.Validate(fields, out enumFieldError, out validatedFields);
// 显示字段错误
IFieldError fieldError;
enumFieldError.Reset();
while ((fieldError = enumFieldError.Next()) != null)
{
IField errorField = fields.Field[fieldError.FieldIndex];
//Console.WriteLine("Field '{0}': Error '{1}'", errorField.Name, fieldError.FieldError);
}
//返回验证的字段
return validatedFields;
}
/// <summary>
/// 删除字段
/// </summary>
/// <param name="pInFields"></param>
/// <param name="pDeleteField"></param>
public static void DeleteField(IFields pInFields, IField pDeleteField)
{
IFieldsEdit pFieldsEdit = pInFields as IFieldsEdit;
if (pFieldsEdit == null) return;
pFieldsEdit.DeleteAllFields(); //删除全部字段
pFieldsEdit.DeleteField(pDeleteField); //删除指定字段
}
/// <summary>
/// 删除字段
/// </summary>
/// <param name="objectClass"></param>
/// <param name="fieldName"></param>
public static void DeleteField(IObjectClass objectClass, string fieldName)
{
// Get the field to be deleted.
int fieldIndex = objectClass.FindField(fieldName);
IField field = objectClass.Fields.Field[fieldIndex];
// Cast to the ISchemaLock interface.
ISchemaLock schemaLock = (ISchemaLock)objectClass;
try
{
// Get an exclusive schema lock on the object class.
schemaLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock);
// Alter the class extension for the class.
objectClass.DeleteField(field);
}
catch (Exception e)
{
// An error was raised; therefore, notify the user.
Console.WriteLine(e.Message);
}
finally
{
// Since the Finally block is always called, the exclusive lock is demoted
// to a shared lock after the field is deleted and after an error is raised.
schemaLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock);
}
}
/// <summary>
/// 拷贝字段
/// </summary>
/// <param name="pInField"></param>
/// <returns></returns>
public static IField CopyField(IField pInField)
{
IField pOutField = (pInField as IClone).Clone() as IField;
return pOutField;
}
/// <summary>
/// 读取blob字段到字符串中
/// </summary>
/// <param name="objValue"></param>
/// <returns></returns>
public string ReadStringFromBlob(object objValue)
{
string result = string.Empty;
IMemoryBlobStreamVariant pMemoryBlobStreamVariant = objValue as IMemoryBlobStreamVariant;
if (pMemoryBlobStreamVariant == null) return result;
pMemoryBlobStreamVariant.ExportToVariant(out objValue);
result = Encoding.Default.GetString(objValue as byte[]);
return result;
}
/// <summary>
/// 读取Blob字段中的二进制字节数组
/// </summary>
/// <param name="objValue"></param>
/// <returns></returns>
public byte[] ReadBytesFromBlob(object objValue)
{
IMemoryBlobStreamVariant pMemoryBlobStreamVariant = objValue as IMemoryBlobStreamVariant;
if (pMemoryBlobStreamVariant != null)
pMemoryBlobStreamVariant.ExportToVariant(out objValue);
byte[] bytes = objValue as byte[];
return bytes;
}
/// <summary>
/// 将字符串写入Blob流对象
/// </summary>
/// <param name="sValue"></param>
/// <returns></returns>
public static IMemoryBlobStream WriteStringToBlob(string sValue)
{
IMemoryBlobStream blobStream = new MemoryBlobStreamClass();
if (string.IsNullOrWhiteSpace(sValue)) return blobStream;
object objValue = Encoding.Default.GetBytes(sValue);
(blobStream as IMemoryBlobStreamVariant).ImportFromVariant(objValue);
return blobStream;
}
/// <summary>
/// 将字节数组写入Blob流对象
/// </summary>
/// <param name="bytes"></param>
/// <returns></returns>
public static IMemoryBlobStream WriteBytesToBlob(byte[] bytes)
{
IMemoryBlobStream blobStream = new MemoryBlobStreamClass();
(blobStream as IMemoryBlobStreamVariant).ImportFromVariant(bytes);
return blobStream;
}
/// <summary>
/// 将Object对象写入到Blob字段中
/// </summary>
/// <param name="rowBuffer"></param>
/// <param name="iFieldIndex"></param>
/// <param name="value"></param>
public static void SaveBlobValue(IRowBuffer rowBuffer, int iFieldIndex, object value)
{
if (value is IPersistStream)
{
IMemoryBlobStream pBlobStream = new MemoryBlobStreamClass();
(value as IPersistStream).Save(pBlobStream, 0);
rowBuffer.set_Value(iFieldIndex, pBlobStream);
}
else
{
IMemoryBlobStream pBlobStream = new MemoryBlobStreamClass();
rowBuffer.set_Value(iFieldIndex, pBlobStream);
}
}
/// <summary>
/// 获取字段的总数
/// </summary>
/// <param name="pFields"></param>
/// <returns></returns>
public static int GetFieldsCount(IFields pFields)
{
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
return pFieldsEdit.FieldCount;
}
public static IGeometryDef GetGeometryDef(IFeatureClass featureClass)
{
// First, determine the name of the shape field.
String shapeFieldName = featureClass.ShapeFieldName;
// Get the feature class fields collection and find the shape field index.
IFields fields = featureClass.Fields;
int geometryIndex = fields.FindField(shapeFieldName);
// Use the index value to get the field.
IField field = fields.Field[geometryIndex];
// Get the GeometryDef from the field and return it.
IGeometryDef geometryDef = field.GeometryDef;
return geometryDef;
}
public static IField CreateStringField(string name, string aliasName, string fieldType, int length)
{
return CreateField(name, aliasName, fieldType, length);
}
public static IField CreateIntegerField(string name, string aliasName, string fieldType, int precision)
{
return CreateField(name, aliasName, fieldType, -1, precision);
}
public static IField CreateFloatField(string name, string aliasName, string fieldType, int precision, int scale)
{
return CreateField(name, aliasName, fieldType, -1, precision, scale);
}
public static IField CreateField(string name, string aliasName, string fieldType, int length = -1, int precision = -1, int scale = -1, object defaultValue = null, bool isNullable = true)
{
IField pField = new FieldClass();
IFieldEdit pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = name;
pFieldEdit.AliasName_2 = aliasName;
esriFieldType esriFieldType = GetGeometryType(fieldType);
switch (esriFieldType)
{
case esriFieldType.esriFieldTypeSmallInteger:
case esriFieldType.esriFieldTypeInteger:
pFieldEdit.Precision_2 = precision;
break;
case esriFieldType.esriFieldTypeSingle:
case esriFieldType.esriFieldTypeDouble:
pFieldEdit.Precision_2 = precision;
pFieldEdit.Scale_2 = scale;
break;
case esriFieldType.esriFieldTypeString:
pFieldEdit.Length_2 = length;
break;
}
pFieldEdit.Type_2 = esriFieldType;
if (defaultValue != null)
pFieldEdit.DefaultValue_2 = defaultValue;
pFieldEdit.IsNullable_2 = isNullable;
return pField;
}
public static IFields CreateFields(IEnumerable<FieldInfo> fieldInfos)
{
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
foreach (FieldInfo fieldInfo in fieldInfos)
pFieldsEdit.AddField(CreateField(fieldInfo));
return pFields;
}
public static IField CreateField(FieldInfo fieldInfo)
{
IField pField = new FieldClass();
IFieldEdit pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = fieldInfo.Name;
pFieldEdit.AliasName_2 = fieldInfo.AliasName;
esriFieldType esriFieldType = GetGeometryType(fieldInfo.Type);
pFieldEdit.Type_2 = esriFieldType;
switch (esriFieldType)
{
case esriFieldType.esriFieldTypeSmallInteger:
case esriFieldType.esriFieldTypeInteger:
pFieldEdit.Precision_2 = fieldInfo.Precision != null ? fieldInfo.Precision.Value : 9;
break;
case esriFieldType.esriFieldTypeSingle:
case esriFieldType.esriFieldTypeDouble:
pFieldEdit.Precision_2 = fieldInfo.Precision != null ? fieldInfo.Precision.Value : 2;
pFieldEdit.Scale_2 = fieldInfo.Scale != null ? fieldInfo.Scale.Value : 2;
break;
case esriFieldType.esriFieldTypeString:
pFieldEdit.Length_2 = fieldInfo.Length == 0 ? 255 : fieldInfo.Length;
break;
}
if (fieldInfo.DefaultValue != null)
pFieldEdit.DefaultValue_2 = fieldInfo.DefaultValue;
pFieldEdit.IsNullable_2 = fieldInfo.IsNullable != null ? fieldInfo.IsNullable.Value : true;
return pField;
}
public static esriFieldType GetGeometryType(string type)
{
return FieldTypes.ContainsKey(type)
? FieldTypes[type]
: esriFieldType.esriFieldTypeString;
}
}
/// <summary>
/// 字段信息
/// </summary>
public class FieldInfo
{
/// <summary>
/// 字段名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 字段别名
/// </summary>
public string AliasName { get; set; }
/// <summary>
/// 字段的类型
/// </summary>
public string Type { get; set; }
/// <summary>
/// 字段长度
/// </summary>
public int Length { get; set; }
/// <summary>
/// 字段的数值精度
/// </summary>
public int? Precision { get; set; }
/// <summary>
/// 字段的小数点位数
/// </summary>
public int? Scale { get; set; }
/// <summary>
/// 是否为空值
/// </summary>
public bool? IsNullable { get; set; }
/// <summary>
/// 默认值
/// </summary>
public object DefaultValue { get; set; }
}
public class FieldInfoEx : FieldInfo
{
}
