public static SqlQuery OrderBy(this SqlQuery query, IField field, bool desc = false)
{
if (field == null)
throw new ArgumentNullException("field");
return query.OrderBy(field.Expression, desc);
}
public static SqlQuery GroupBy(this SqlQuery query, IField field)
{
if (field == null)
throw new ArgumentNullException("field");
return query.GroupBy(field.Expression);
}
/// <summary>
/// Adds any child properties that are linked to the field.
/// </summary>
/// <param name="child">The child whose properties are being added.</param>
public override void AddChildProperties(IField child)
{
base.AddChildProperties(child);
// Position the child within the grid.
if (_positions.Columns != null)
{
Tuple<int, int> rowAndColumn = _positions.GetNextRowAndColumn();
int column = rowAndColumn.Item2;
int row = rowAndColumn.Item1;
child.AddTypedProperty("Grid.Column", column);
child.AddTypedProperty("Grid.Row", row);
IList<IProperty> properties = child.Element.Properties.Find("Across");
_positions.MakeItemUsed(row, column);
if (properties != null && properties.Count > 0)
{
IProperty across = properties[0];
if (across != null)
{
int columns = across.IntValue;
for (int i = 1; i < columns; ++i)
_positions.MakeItemUsed(row, column + i);
child.AddTypedProperty("Grid.ColumnSpan", columns);
if (properties.Count > 1)
{
int rows = properties[1].IntValue;
child.AddTypedProperty("Grid.RowSpan", rows);
for (int col = 0; col < columns; ++col)
for (int i = 0; i < rows; ++i)
_positions.MakeItemUsed(row + i, column + col);
}
}
}
}
}
/// <summary>
/// Initializes a new instance of the MoveableField class.
/// </summary>
/// <param name="field"> The field.</param>
/// <param name="movement">(optional) The movement.</param>
public MoveableField(IField field, IMovement movement = null)
{
Validation.ThrowIfNull(field);
this._field = field;
this._movement = movement ?? new BackwardMovement(field);
}
private void AddNewField(IField field)
{
var newFields = new IField[_fields.Length + 1];
newFields[_fields.Length] = field;
Array.Copy(_fields, 0, newFields, 0, _fields.Length);
_fields = newFields;
}
public static object GetDefaultValueForField(IRow row, IField fld)
{
object defaultValue = DBNull.Value;
if (!fld.IsNullable)
defaultValue = string.Empty;
if (row != null && fld != null)
{
IClass cls = row.Table;
if (HasSubtype(cls))
{
ISubtypes subTypes = (ISubtypes)cls;
string subTypeFieldName = GetSubTypeFieldName(cls);
if (string.IsNullOrEmpty(subTypeFieldName) == false)
{
object o = GetFieldValue(row, subTypeFieldName);
int subTypeCode = ToInteger(o, -1);
if (subTypeCode != -1)
defaultValue = subTypes.get_DefaultValue(subTypeCode, fld.Name);
}
}
if (defaultValue == DBNull.Value && fld.Type == esriFieldType.esriFieldTypeDate)
defaultValue = fld.DefaultValue;
}
return defaultValue;
}
/// <summary>
/// Creates a new criteria that contains field name of the metafield.</summary>
/// <param name="field">
/// Field (required).</param>
public Criteria(IField field)
{
if (field == null)
throw new ArgumentNullException("field");
this.expression = field.Expression;
}
public void SetMainMember(IField field)
{
this.Member = field;
this.MemberType = MemberTypes.Field;
this.SubMemberType = this.MemberType;
this.SubMember = this.Member;
}
public FieldCondition(Range operand, IField field)
: base(operand, field)
{
// Field can't be null when using a range
if (field == null)
throw new ArgumentNullException("field");
}
public void Move(IField oldField, IField field)
{
IMoveable moveable = oldField.Moveables.First();
field.PlaceMoveable(moveable);
oldField.RemoveMoveable(moveable);
Position = field;
}
public NearCondition(StringValue operand, IField field = null, uint? boost = null, uint? distance = null)
: base(operand, field, boost)
{
Distance = distance;
if (Distance.HasValue) AddOption("distance", Distance.ToString());
}
public GameViewModel(ViewModelMetadata viewModelMetadata) : base(viewModelMetadata)
{
BackToMainMenuCommand = new RelayCommand(x => OnChangeViewModel(typeof(StartViewModel)));
KeyDownCommand = new RelayCommand(HandleKeyDownCommand);
FieldHeight = 20;
FieldWidth = 20;
var test = new IField[FieldHeight, FieldWidth];
for (int x = 0; x < 20; x++)
{
for (int y = 0; y < 20; y++)
{
if (x == 10)
test[y, x] = new Field()
{
Background = Brushes.Yellow,
X = x,
Y = y,
};
else
test[y, x] = new Field()
{
Background = Brushes.Brown,
X = x,
Y = y
};
}
}
Fields = new IField[FieldHeight, FieldWidth];
Fields = test;
GameController = new GameController.GameController(Fields, OnPropertyChanged);
}
public MemberNode(IField field)
{
InitMemberNode(field);
sortOrder = 11;
Text = AppendReturnType(GetAmbience().Convert(field), field.ReturnType);
SelectedImageIndex = ImageIndex = ClassBrowserIconService.GetIcon(field).ImageIndex;
}
public GenericAccountFieldViewModel(IField field)
{
FieldName = field.Name;
FieldValue = field.Value as string;
CopyButtonText = "copy " + FieldName;
IsCopyButtonVisible = true;
}
public void Init()
{
this._field = new Field();
this._field.Position = new Position(2, 2);
this._originalPosition = this._field.Position.Clone();
this._movement = new StraightMovement(this._field);
}
public Return(IField field)
{
if (field == null)
throw new ArgumentNullException("field");
_field = field;
}
public PropertyWrapper(PropertyInfo property)
{
this.property = property;
this.fieldDescriptor = ExtractFieldAttributeFrom(property);
if (IsValid)
Optimize(property);
}
public static IField AlterRasterFieldSR(IField pField, ISpatialReference sr)
{
IFieldEdit2 pEdit = pField as IFieldEdit2;
IRasterDef pRDef = pEdit.RasterDef;
pRDef.SpatialReference = sr;
return pField;
}
public void Validate(IField field)
{
var thisHindrRecMes = new KeyData<Rectangle, string>(
Rect,
"hindrance (" + ToString() + ")");
if (!field.Rect.Contains(thisHindrRecMes.Key))
throw new RectIsNotInsideAnotherRectException(
thisHindrRecMes.Data,
string.Format("field (Panel with Size = ({0}, {1}))", field.Size.Width, field.Size.Height)
);
var anotherRectMes = new KeyData<Rectangle, string>();
foreach (var tank in field.Tanks)
{
anotherRectMes.Key = tank.Rect;
anotherRectMes.Data = "tank (" + tank.ToString() + ")";
rectValidator.Validate(thisHindrRecMes, anotherRectMes);
}
foreach (var hindr in field.Hindrances)
if (ID != hindr.ID)
{
anotherRectMes.Key = hindr.Rect;
anotherRectMes.Data = "hindrance (" + hindr.ToString() + ")";
rectValidator.Validate(thisHindrRecMes, anotherRectMes);
}
}
public GameMechanics(IField field, IBlockFactory blockFactory)
{
this.field = field;
this.blockFactory = blockFactory;
this.currentBlock = blockFactory.MakeBlock();
field.SetBlock(currentBlock, new Vector2(0, 0));
}
public string GetIcon(IField field)
{
if (field.IsLiteral)
return Stock.Literal;
return GetWithModifiers (field.Modifiers, Stock.Field, Stock.ProtectedField, Stock.InternalField, Stock.PrivateField);
}
public virtual int CompareTo(IField field)
{
int cmp;
cmp = base.CompareTo((IDecoration)field);
if (cmp != 0) {
return cmp;
}
if (FullyQualifiedName != null) {
cmp = FullyQualifiedName.CompareTo(field.FullyQualifiedName);
if (cmp != 0) {
return cmp;
}
}
if (FullyQualifiedName != null) {
cmp = FullyQualifiedName.CompareTo(field.FullyQualifiedName);
if (cmp != 0) {
return cmp;
}
}
if (ReturnType != null) {
cmp = ReturnType.CompareTo(field.ReturnType);
if (cmp != 0) {
return cmp;
}
}
if (Region != null) {
return Region.CompareTo(field.Region);
}
return 0;
}
/// <summary>
/// Prints the game field.
/// </summary>
/// <param name="gameField">The field to be printed.</param>
/// <param name="hasBoomed">check if player has explode</param>
public void PrintGameField(IField gameField, bool hasBoomed)
{
if (gameField == null)
{
throw new ArgumentNullException("Game field is null!");
}
string[,] fieldMatrix = gameField.Matrix;
Console.WriteLine();
Console.WriteLine(" 0 1 2 3 4 5 6 7 8 9");
Console.WriteLine(" ---------------------");
for (int row = 0; row < gameField.Rows; row++)
{
Console.Write("{0} | ", row);
for (int col = 0; col < gameField.Cols; col++)
{
string currentSymbol = fieldMatrix[row, col];
PrintCurrentSymbol(currentSymbol, hasBoomed);
}
Console.WriteLine("|");
}
Console.WriteLine(" ---------------------");
}
public FieldInfo resolve(IField fieldRef)
{
var resolver = getTypeResolver(fieldRef.DeclaringType);
if (resolver != null)
return resolver.resolve(fieldRef);
return resolveGlobalField(fieldRef);
}
public FieldDrop(ITable table, IField field)
: base(field)
{
Field = field;
Table = table;
tableMemberDrop = new TableMemberDrop(table, field);
}
protected override void ReplaceFieldDeclaration(IDocument document, IField oldField, string newFieldDeclaration)
{
// In VB, the field region begins at the start of the declaration
// and ends on the first column of the line following the declaration.
int startOffset = document.PositionToOffset(oldField.Region.BeginLine, 1);
int endOffset = document.PositionToOffset(oldField.Region.EndLine, 1);
document.Replace(startOffset, endOffset - startOffset, tabs + newFieldDeclaration + Environment.NewLine);
}
public FieldWrapper(IField member)
{
if (member == null)
throw new ArgumentNullException("member");
this.field = member;
addSetter = true;
}
public int ChainReact(IField field)
{
var bombsDetonated = this.chainedBombs.Sum(bomb => field.Explode(bomb, false, null));
this.chainedBombs.Clear();
return bombsDetonated;
}
FieldInfo ResolveGlobalField(IField fieldRef) {
InitGlobalFields();
foreach (var globalField in globalFields) {
if (ResolverUtils.CompareFields(globalField, fieldRef))
return globalField;
}
return null;
}
protected override void RemoveFieldDeclaration(IDocument document, IField field)
{
// In VB, the field region begins at the start of the declaration
// and ends on the first column of the line following the declaration.
int startOffset = document.PositionToOffset(field.Region.BeginLine, 1);
int endOffset = document.PositionToOffset(field.Region.EndLine, 1);
document.Remove(startOffset, endOffset - startOffset);
}
public Statement CreateFieldAssignment(LexicalInfo lexicalInfo, IField fieldEntity, Expression initializer)
{
return(new ExpressionStatement(lexicalInfo,
CreateFieldAssignmentExpression(fieldEntity, initializer)));
}
public override T Accept <T>(IFieldVisitor <T> visitor, IField field)
{
return(visitor.Visit((IField <TagsFieldProperties>)field));
}
/// <summary>
/// 实现导入导出
/// </summary>
/// <param name="inputFeatureClass"></param>
/// <param name="targetpath"></param>
/// <param name="targetname"></param>
public static void CopyData(IFeatureClass inputFeatureClass, IWorkspace pWorkspace, string targetname)
{
IDataset inputDataset = (IDataset)inputFeatureClass;
IFeatureClassName inputclassName = (IFeatureClassName)inputDataset.FullName;
// Get the layer's selection set.
//利用属性打开
// IPropertySet ps = new PropertySetClass();
// ps.SetProperty("DATABASE", targetpath);
// IWorkspaceFactory wsf = new FileGDBWorkspaceFactoryClass();
// IWorkspace ws = null;
// try
// {
// ws = wsf.Open(ps, 0);
// }
// catch (Exception e)
// {
//
// }
//设置输出要素属性
IDataset ds = (IDataset)pWorkspace;
IWorkspaceName wsName = (IWorkspaceName)ds.FullName;
IFeatureClassName featClsName = new FeatureClassNameClass();
IDatasetName dsName = (IDatasetName)featClsName;
dsName.WorkspaceName = wsName;
dsName.Name = targetname;
//// Use the IFieldChecker interface to make sure all of the field names are valid for a shapefile.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields shapefileFields = null;
IEnumFieldError enumFieldError = null;
fieldChecker.InputWorkspace = inputDataset.Workspace;
fieldChecker.ValidateWorkspace = pWorkspace;
//out and ref
//////////////////用Ref型参数时，传入的参数必须先被初始化。而Out则不要要，对Out而言，就必须在方法中对其完成初始化。
// ///////////////用Ref和Out时都必须注意，在方法的参数和执行方法时，都要加Ref或Out关键字。以满足匹配。
/////////////////// Out更适合用在要要Return多个返回值的地方，而Ref则用在要要被调出使用的方法修改调出使用者的引用的时候。
fieldChecker.Validate(inputFeatureClass.Fields, out enumFieldError, out shapefileFields);
// At this point, reporting/inspecting invalid fields would be useful, but for this example it's omitted.
// We also need to retrieve the GeometryDef from the input feature class.
int shapeFieldPosition = inputFeatureClass.FindField(inputFeatureClass.ShapeFieldName);
IFields inputFields = inputFeatureClass.Fields;
IField shapeField = inputFields.get_Field(shapeFieldPosition);
IGeometryDef geometryDef = shapeField.GeometryDef;
IGeometryDef pGeometryDef = new GeometryDef();
IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit;
pGeometryDefEdit.GeometryType_2 = inputFeatureClass.ShapeType;
IFeature pFeature = inputFeatureClass.Search(null, true).NextFeature();
pGeometryDefEdit.SpatialReference_2 = pFeature.Shape.SpatialReference;
// Now we can create a feature data converter.
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertFeatureClass(inputclassName, null,
null, featClsName, pGeometryDef, shapefileFields, "", 1000, 0);
// Again, checking for invalid objects would be useful at this point...
inputFeatureClass = null;
ds = null;
}
/// <inheritdoc/>
public override string Mangle(IField field, bool mangleFullName)
{
return(field.Name.ToString());
}
//合并要素
private void UnionFeatures(IEnumFeature selectedFeatures, IFeature pMergeFeature)
{
IFeature feature = null;
IGeometry geometry = null;
object missing = Type.Missing;
selectedFeatures.Reset();
feature = selectedFeatures.Next();
if (feature == null)
{
return;
}
IFeatureClass featureClass = feature.Class as IFeatureClass;
IGeometryCollection geometries = new GeometryBagClass();
IDataset dataset = null;
while (feature != null)
{
geometry = feature.ShapeCopy;
geometries.AddGeometry(geometry, ref missing, ref missing);
feature = selectedFeatures.Next();
}
ITopologicalOperator2 unionedGeometry = null;
switch (featureClass.ShapeType)
{
case esriGeometryType.esriGeometryMultipoint:
unionedGeometry = new MultipointClass(); break;
case esriGeometryType.esriGeometryPolyline:
unionedGeometry = new PolylineClass(); break;
case esriGeometryType.esriGeometryPolygon:
unionedGeometry = new PolygonClass(); break;
default: break;
}
IEnumGeometry enuGeo = geometries as IEnumGeometry;
unionedGeometry.ConstructUnion(enuGeo);
ITopologicalOperator2 topo = unionedGeometry as ITopologicalOperator2;
topo.IsKnownSimple_2 = false; topo.Simplify();
IFeatureClass targetFeatureClass = currentLayer.FeatureClass;
dataset = featureClass as IDataset;
selectedFeatures.Reset();
//如果没有IWorkspaceEdit则无法进行撤销重做操作
IWorkspaceEdit workspaceEdit = dataset.Workspace as IWorkspaceEdit;
try
{
//workspaceEdit.StartEditOperation();
IFeature unionedFeature = targetFeatureClass.CreateFeature();
IFields pFields = unionedFeature.Fields;
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
IField pField = null;
for (int i = 0; i < pFields.FieldCount; i++)
{
pField = pFields.Field[i];
if (targetFeatureClass.AreaField != null && targetFeatureClass.LengthField != null)
{
if (pField.Name != targetFeatureClass.OIDFieldName && pField.Name != targetFeatureClass.ShapeFieldName &&
pField.Name != targetFeatureClass.AreaField.Name && pField.Name != targetFeatureClass.LengthField.Name)
{
unionedFeature.set_Value(i, pMergeFeature.Value[i]);
}
}
else
{
if (pField.Name != targetFeatureClass.OIDFieldName && pField.Name != targetFeatureClass.ShapeFieldName)
{
unionedFeature.set_Value(i, pMergeFeature.Value[i]);
}
}
}
unionedFeature.Shape = unionedGeometry as IGeometry;
unionedFeature.Store();
while ((feature = selectedFeatures.Next()) != null)
{
feature.Delete();
}
workspaceEdit.StopEditOperation();
}
catch (Exception ex)
{
//SysLogHelper.WriteOperationLog("要素合并错误", ex.Source, "数据编辑");
MessageBox.Show(ex.Message);
}
}
public static IList <IParameter> AsParameters(this IField source, params string[] header) => source.Select(header).AsParameters();
public static IList <IParameter> AsParameters(this IField source, IEnumerable <string> header) => source.Select(header).AsParameters();
public static ICell GetCell(this IField field, int x, int y)
{
return(field.Cells[x, y]);
}
public static IParameter AsParameter(this IField field, string parameterName) => new Parameter(parameterName, field);
public static ICell GetCell(this IField field, int num)
{
var converted = field.ConvertCoords(num);
return(field.GetCell(converted[0], converted[1]));
}
/// <summary> /// Updates the value of an object's field. /// </summary> /// <param name="obj">An object that contains <paramref name="field"/>.</param> /// <param name="field">A field to update.</param> /// <param name="value">The value to assign to <paramref name="field"/> in <paramref name="obj"/>.</param> public abstract void SetField(TObj obj, IField field, TObj value);
private void ReadFieldElement(
XmlReader reader, dynamic entity, Dictionary <string, object> record)
{
var refKey = reader["ref-key"] as string;
if (refKey != null)
{
refKey.Trim();
}
var refEntity = reader["ref-entity"] as string;
if (refEntity != null)
{
refEntity.Trim();
}
var fieldName = (string)reader["name"];
fieldName.Trim();
if (!entity.Fields.ContainsKey(fieldName))
{
var msg = string.Format("Cannot found field: [{0}]", fieldName);
throw new ArgumentOutOfRangeException(msg);
}
IField metaField = entity.Fields[fieldName];
object fieldValue = null;
switch (metaField.Type)
{
case FieldType.BigInteger:
fieldValue = reader.ReadElementContentAsLong();
break;
case FieldType.Integer:
fieldValue = reader.ReadElementContentAsInt();
break;
case FieldType.Boolean:
fieldValue = reader.ReadElementContentAsBoolean();
break;
case FieldType.Double:
fieldValue = reader.ReadElementContentAsDouble();
break;
case FieldType.DateTime:
case FieldType.Date:
case FieldType.Time:
fieldValue = reader.ReadElementContentAsDateTime();
break;
case FieldType.Decimal:
fieldValue = reader.ReadElementContentAsDecimal();
break;
case FieldType.Chars:
case FieldType.Text:
case FieldType.Xml:
case FieldType.Enumeration:
fieldValue = reader.ReadElementContentAsString().Trim();
break;
case FieldType.Reference:
if (string.IsNullOrEmpty(refKey) || string.IsNullOrEmpty(refEntity))
{
throw new DataException(
"Reference field must have 'ref-key' and 'ref-entity' attributes");
}
var recordId = EntityDataEntity.TryLookupResourceId(
this.context.DataContext, refEntity, refKey);
if (recordId == null)
{
var msg = string.Format(
"Cannot found entity for reference field: {0}:{1}", refEntity, refKey);
throw new DataException(msg);
}
fieldValue = new object[] { refEntity, recordId };
break;
case FieldType.ManyToOne:
if (string.IsNullOrEmpty(refKey))
{
throw new DataException("Many-to-one field must have a 'ref-key' attribute");
}
fieldValue = EntityDataEntity.TryLookupResourceId(
this.context.DataContext, metaField.Relation, refKey);
if (fieldValue == null)
{
throw new DataException("Cannot found entity for ref-key: " + refKey);
}
break;
default:
throw new NotSupportedException();
}
record[metaField.Name] = fieldValue;
}
public static NamedId <long> NamedId(this IField field)
{
return(NamedIdStatic.Of(field.Id, field.Name));
}
public static IconId GetStockIcon(this IField field)
{
return(GetStockIcon((IEntity)field));
}
/// <summary> /// Gets the given field's mangled name. /// </summary> /// <param name="Field">The field whose name is to be mangled.</param> /// <param name="mangleFullName"> /// If this is <c>true</c>, then the field's full name is /// mangled. Otherwise, only its name is mangled. /// </param> /// <returns>The mangled name.</returns> public abstract string Mangle(IField method, bool mangleFullName);
public FieldObject(IField ifield_1)
{
this.ifield_0 = ifield_1;
}
public (IGraphType ResolveType, ValueResolver Resolver) GetGraphType(ISchemaEntity schema, IField field, string fieldName)
{
return(field.Accept(new QueryGraphTypeVisitor(schema, GetContentType, this, assetListType, fieldName)));
}
public static void AddFields(Dynamic.FieldSet fields, TCM.Fields.ItemFields tcmItemFields, int currentLinkLevel, BuildManager manager)
{
foreach (TCM.Fields.ItemField tcmItemField in tcmItemFields)
{
try
{
if (fields.ContainsKey(tcmItemField.Name))
{
log.Debug("field exists already, with " + fields[tcmItemField.Name].Values.Count + " values");
if (manager.BuildProperties.MergeAction.Equals(Dynamic.MergeAction.Skip) || (manager.BuildProperties.MergeAction.Equals(Dynamic.MergeAction.MergeMultiValueSkipSingleValue) && tcmItemField.Definition.MaxOccurs == 1))
{
log.Debug(string.Format("skipping field (merge action {0}, maxoccurs {1}", manager.BuildProperties.MergeAction.ToString(), tcmItemField.Definition.MaxOccurs));
continue;
}
Dynamic.Field f = manager.BuildField(tcmItemField, currentLinkLevel);
if (manager.BuildProperties.MergeAction.Equals(Dynamic.MergeAction.Replace) || (manager.BuildProperties.MergeAction.Equals(Dynamic.MergeAction.MergeMultiValueReplaceSingleValue) && tcmItemField.Definition.MaxOccurs == 1))
{
log.Debug(string.Format("replacing field (merge action {0}, maxoccurs {1}", manager.BuildProperties.MergeAction.ToString(), tcmItemField.Definition.MaxOccurs));
fields.Remove(f.Name);
fields.Add(f.Name, f);
}
else
{
IField existingField = fields[f.Name];
switch (existingField.FieldType)
{
case FieldType.ComponentLink:
case FieldType.MultiMediaLink:
foreach (Component linkedComponent in f.LinkedComponentValues)
{
bool valueExists = false;
foreach (Component existingLinkedComponent in existingField.LinkedComponentValues)
{
if (linkedComponent.Id.Equals(existingLinkedComponent.Id))
{
// this value already exists
valueExists = true;
break;
}
}
if (!valueExists)
{
existingField.LinkedComponentValues.Add(linkedComponent);
}
}
break;
case FieldType.Date:
foreach (DateTime dateTime in f.DateTimeValues)
{
bool valueExists = false;
foreach (DateTime existingDateTime in existingField.DateTimeValues)
{
if (dateTime.Equals(existingDateTime))
{
// this value already exists
valueExists = true;
break;
}
}
if (!valueExists)
{
existingField.DateTimeValues.Add(dateTime);
}
}
break;
case FieldType.Number:
foreach (int nr in f.NumericValues)
{
bool valueExists = false;
foreach (int existingNr in existingField.NumericValues)
{
if (nr == existingNr)
{
// this value already exists
valueExists = true;
break;
}
}
if (!valueExists)
{
existingField.NumericValues.Add(nr);
}
}
break;
default:
foreach (string val in f.Values)
{
bool valueExists = false;
foreach (string existingVal in existingField.Values)
{
if (val.Equals(existingVal))
{
// this value already exists
valueExists = true;
break;
}
}
if (!valueExists)
{
existingField.Values.Add(val);
}
}
break;
}
}
}
else
{
Dynamic.Field f = manager.BuildField(tcmItemField, currentLinkLevel);
fields.Add(f.Name, f);
}
}
catch (FieldHasNoValueException)
{
// fail silently, field is not added to the list
}
catch (FieldTypeNotDefinedException)
{
// fail silently, field is not added to the list
}
}
}
public Expression CreateFieldAssignmentExpression(IField fieldEntity, Expression initializer)
{
return(CreateAssignment(initializer.LexicalInfo, CreateReference(fieldEntity), initializer));
}
public override void Implement(MethodBodyTransformationContext context)
{
/* We want to generate the following
* if ( !this.<>4__this.Dispatcher.CheckAccess() )
* {
* SynchronizationContext oldContext = SynchronizationContext.Current;
* SynchronizationContext.SetSynchronizationContext( this.<>4__this.Dispatcher.SynchronizationContext );
* this.<>t__dispatchAwaiter = Task.Yield().GetAwaiter();
* this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Player.<Ping>d__2>(ref this.<>t__dispatchAwaiter, ref this);
* SynchronizationContext.SetSynchronizationContext( oldContext );
* return;
* }
*
*/
MethodDefDeclaration targetMethod = (MethodDefDeclaration)context.TargetElement;
TypeDefDeclaration targetType = targetMethod.DeclaringType;
targetMethod.MethodBody.MaxStack = -1;
// Add the field where we will store the awaiter.
FieldDefDeclaration awaiterFieldDef = new FieldDefDeclaration
{
Name = "<>t__dispatchAwaiter",
FieldType = this.parent.yieldAwaiter_Type,
Attributes = FieldAttributes.Private
};
targetType.Fields.Add(awaiterFieldDef);
IField awaiterField = awaiterFieldDef.GetCanonicalGenericInstance();
// Find other fields.
IField thisField = targetType.Fields.Single <FieldDefDeclaration>(f => f.Name.EndsWith("__this")).GetCanonicalGenericInstance();
IField builderField = targetType.Fields.GetByName("<>t__builder").GetCanonicalGenericInstance();
// Emit instructions.
InstructionBlock myBlock = context.InstructionBlock.AddChildBlock(null, NodePosition.After, null);
InstructionBlock theirBlock = context.InstructionBlock.AddChildBlock(null, NodePosition.After, null);
LocalVariableSymbol awaitableLocal = myBlock.DefineLocalVariable(this.parent.task_Yield_Method.ReturnType, "awaitable");
LocalVariableSymbol synchronizationContextLocal = myBlock.DefineLocalVariable(this.parent.synchronizationContext_Type, "oldContext");
InstructionSequence entrySequence = myBlock.AddInstructionSequence(null, NodePosition.After, null);
InstructionSequence exitSequence = myBlock.AddInstructionSequence(null, NodePosition.After, null);
InstructionWriter writer = new InstructionWriter();
writer.AttachInstructionSequence(entrySequence);
// Emit: if ( this.<>4__this.Dispatcher.CheckAccess() ) goto exitSequence;
writer.EmitInstruction(OpCodeNumber.Ldarg_0);
writer.EmitInstructionField(OpCodeNumber.Ldfld, thisField);
writer.EmitInstructionMethod(OpCodeNumber.Call, this.parent.actor_GetDispatcher_Method);
writer.EmitInstructionMethod(OpCodeNumber.Callvirt, this.parent.dispatcher_CheckAccess_Method);
writer.EmitBranchingInstruction(OpCodeNumber.Brtrue, exitSequence);
// Emit: this.<>t__dispatchAwaiter = Task.Yield().GetAwaiter()
writer.EmitInstruction(OpCodeNumber.Ldarg_0);
writer.EmitInstructionMethod(OpCodeNumber.Call, this.parent.task_Yield_Method);
writer.EmitInstructionLocalVariable(OpCodeNumber.Stloc, awaitableLocal);
writer.EmitInstructionLocalVariable(OpCodeNumber.Ldloca, awaitableLocal);
writer.EmitInstructionMethod(OpCodeNumber.Call, this.parent.yieldAwaitable_GetAwaiter_Method);
writer.EmitInstructionField(OpCodeNumber.Stfld, awaiterField);
// Emit: oldContext = SynchronizationContext.Current
writer.EmitInstructionMethod(OpCodeNumber.Call, this.parent.synchronizationContext_getCurrent_Method);
writer.EmitInstructionLocalVariable(OpCodeNumber.Stloc, synchronizationContextLocal);
// Emit: SynchronizationContext.SetSynchronizationContext(this.<>4__this.Dispatcher.SynchronizationContext)
writer.EmitInstruction(OpCodeNumber.Ldarg_0);
writer.EmitInstructionField(OpCodeNumber.Ldfld, thisField);
writer.EmitInstructionMethod(OpCodeNumber.Call, this.parent.actor_GetDispatcher_Method);
writer.EmitInstructionMethod(OpCodeNumber.Callvirt, this.parent.dispatcher_getSynchronizationContext_Method);
writer.EmitInstructionMethod(OpCodeNumber.Call, this.parent.synchronizationContext_SetSynchronizationContext_Method);
// Choose which AwaitUnsafeOnCompleted method to call.
IGenericMethodDefinition awaitUnsafeOnCompletedMethod;
ITypeSignature[] awaitUnsafeOnCompletedGenericTypeParameters;
if (builderField.FieldType == this.parent.asyncVoidMethodBuilder_Type)
{
awaitUnsafeOnCompletedMethod = this.parent.asyncVoidMethodBuilder_AwaitUnsafeOnCompleted_Method;
awaitUnsafeOnCompletedGenericTypeParameters = null;
}
else if (builderField.FieldType == this.parent.asyncTaskMethodBuilder_Type)
{
awaitUnsafeOnCompletedMethod = this.parent.asyncTaskMethodBuilder_AwaitUnsafeOnCompleted_Method;
awaitUnsafeOnCompletedGenericTypeParameters = null;
}
else
{
// This is a generic task.
awaitUnsafeOnCompletedMethod = this.parent.asyncTaskMethodBuilderGeneric_AwaitUnsafeOnCompleted_Method;
awaitUnsafeOnCompletedGenericTypeParameters =
builderField.FieldType.GetGenericContext(GenericContextOptions.None).GetGenericTypeParameters();
}
IMethod awaitUnsafeOnCompletedGenericMethod =
awaitUnsafeOnCompletedMethod.GetGenericInstance(new GenericMap(awaitUnsafeOnCompletedGenericTypeParameters,
new ITypeSignature[]
{
this.parent.yieldAwaiter_Type,
targetType.GetCanonicalGenericInstance()
}));
// Emit: this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Player.<Ping>d__2>(ref this.<>t__dispatchAwaiter, ref this);
writer.EmitInstruction(OpCodeNumber.Ldarg_0);
writer.EmitInstructionField(OpCodeNumber.Ldflda, builderField);
writer.EmitInstruction(OpCodeNumber.Ldarg_0);
writer.EmitInstructionField(OpCodeNumber.Ldflda, awaiterField);
writer.EmitInstruction(OpCodeNumber.Ldarg_0);
writer.EmitInstructionMethod(OpCodeNumber.Call, awaitUnsafeOnCompletedGenericMethod);
// Emit: SynchronizationContext.SetSynchronizationContext( oldContext );
writer.EmitInstructionLocalVariable(OpCodeNumber.Ldloc, synchronizationContextLocal);
writer.EmitInstructionMethod(OpCodeNumber.Call, this.parent.synchronizationContext_SetSynchronizationContext_Method);
writer.EmitBranchingInstruction(OpCodeNumber.Leave, context.LeaveBranchTarget);
writer.DetachInstructionSequence();
// We are done. Give the pipeline to the next node.
context.AddRedirection(theirBlock, context.LeaveBranchTarget);
}
public MemberReferenceExpression CreateReference(IField field)
{
return(CreateMemberReference(field));
}
private static bool IsFieldMatchingConfigurationOptions(IField field, ImplicitNullabilityConfiguration configuration)
{
return
((!configuration.HasFieldOption(ImplicitNullabilityFieldOptions.RestrictToReadonly) || field.IsReadonly) &&
(!configuration.HasFieldOption(ImplicitNullabilityFieldOptions.RestrictToReferenceTypes) || field.IsMemberOfReferenceType()));
}
//=================================================================================================================
//=================================================================================================================
//陈胜鹏 2009-08-20 添加
/// <summary>
/// 主要是用来显示对应OID的属性值 给属性显示控件提供数据
/// <para>key=name+oid value=field +value</para>
/// <remarks>利用数据字典，将要素类的名称和单个的OID作为一个KEY，然后把OID里的字段和值取出来当作值</remarks>
/// </summary>
/// <returns></returns>
private Hashtable GetData_View()
{
Hashtable table = new Hashtable();
IEnumFeature f_dataset = myHook.MapControl.Map.FeatureSelection as IEnumFeature;//取得地图控件上被选择的要素集
f_dataset.Reset();
IFeature feature = f_dataset.Next();//取得下一个要素
string name = "";
string oid = "";
#region 遍历对应要素类下对应OID要素的记录值
while (feature != null)
{
name = feature.Class.AliasName;
oid = feature.OID.ToString();
string key = name + oid; //使用KEY值,把要素类的名称加上单个的OID组合成一个KEY
string Value = ""; //使用VALUE
string shape = ""; //确定要素的SHAPE是什么
#region 得到要素的SHAPE类型：注记，面，线，点
if (feature.FeatureType == esriFeatureType.esriFTAnnotation)
{
shape = "注记";
}
else
{
IGeometry geometry = feature.Shape; //得到要素的几何图形
switch (geometry.GeometryType.ToString()) //确定它的几何要素类型
{
case "esriGeometryPolygon":
shape = "面";
break;
case "esriGeometryPolyline":
shape = "线";
break;
case "esriGeometryPoint":
shape = "点";
break;
}
}
#endregion
IFields fields = feature.Fields;
int k = fields.FieldCount;
#region 此遍历主要是用来得到一整条要素的记录，把它进行组合成一个VALUE
for (int s = 0; s < k; s++)
{
IField field = fields.get_Field(s);
string str = "";
string f_value = feature.get_Value(s).ToString();//得到对应列值
if (field.Name.ToLower() == "shape")
{
str = "SHAPE " + shape;//得到对应的SHAPE类型
}
else if (field.Name.ToLower() == "element")
{
str = "Element blob";
}
else
{
if (f_value != string.Empty)
{
str = field.Name + " " + f_value;
}
else
{
str = field.Name + " " + "null";
}
}
Value += str + ",";
}
#endregion
#region 把KEY和VALUE加入到数据字典当中，以备后面使用
if (table.Count == 0)
{
table.Add(key, Value);
}
else
{
table.Add(key, Value);
}
#endregion
feature = f_dataset.Next();
}
#endregion
if (table.Count == 0)
{
table = null;
}
return(table);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.activity_game);
if (Intent.HasExtra("Level"))
{
Enum.TryParse <FieldType>(Intent.GetStringExtra("Level"), out var ftype);
mineField = FieldFactory.GetPredefinedField(ftype);
}
else
{
var raw = Intent.GetStringExtra("Field").Split('-');
mineField =
FieldFactory.GetCustomField(int.Parse(raw[0]), int.Parse(raw[1]),
int.Parse(raw[2]));
}
timer = FindViewById <Chronometer>(Resource.Id.gameTimer);
var field = FindViewById <GridView>(Resource.Id.cellField);
field.SetNumColumns(mineField.Width);
field.Adapter = new CellAdapter(this, mineField);
field.ItemClick += delegate(object sender, AdapterView.ItemClickEventArgs args)
{
if (state == GameState.Idle)
{
timer.Start();
state = GameState.Running;
}
else if (state != GameState.Running)
{
return;
}
TryOpenCell(sender, args);
ValidateGameState();
field.InvalidateViews();
if (state != GameState.Running)
{
ShowEndDialog();
}
};
field.ItemLongClick += delegate(object sender, AdapterView.ItemLongClickEventArgs args)
{
if (state == GameState.Idle)
{
timer.Start();
state = GameState.Running;
}
else if (state != GameState.Running)
{
return;
}
TryFlagCell(sender, args);
ValidateGameState();
field.InvalidateViews();
if (state != GameState.Running)
{
ShowEndDialog();
}
};
}
private void treeLayer_AfterCheckNode(object sender, NodeEventArgs e)
{
this.teValue.Text = "";
this.listBoxControlValues.Items.Clear();
this.selectFeatureClass.Clear();
try
{
List <string> list = new List <string>();
foreach (TreeListNode node in this.treeLayer.GetAllCheckedNodes())
{
object obj = node.GetValue("NodeObject");
if (obj is DF2DFeatureClass)
{
DF2DFeatureClass dffc = obj as DF2DFeatureClass;
selectFeatureClass.Add(dffc);
IFeatureClass fc = dffc.GetFeatureClass();
FacilityClass fac = dffc.GetFacilityClass();
if (fc == null || fac == null)
{
continue;
}
//List<FieldInfo> list1 = dffc.GetFacilityClass().FieldInfoCollection;
//for (IField f in fc.Fields)
//{
// foreach (FieldInfo fi in list1)
// {
// if (fi.Name = f.Name && fi.CanQuery)
// {
// }
// }
//}
DFDataConfig.Class.FieldInfo fi = fac.GetFieldInfoBySystemName(this._sysFieldName);
fieldName = fi.Name;
IFields fiCol = fc.Fields;
int index = fiCol.FindField(fi.Name);
if (index < 0)
{
continue;
}
IField pField = fiCol.get_Field(index);
IQueryFilter filter = new QueryFilterClass();
filter.SubFields = pField.Name;
IFeatureCursor ftCursor = fc.Search(filter, true);
IFeature pfeature = ftCursor.NextFeature();
while (pfeature != null)
{
string temp = pfeature.get_Value(index).ToString();
if (temp != null)
{
list.Add(temp);
}
pfeature = ftCursor.NextFeature();
}
}
}
if (list.Count > 0)
{
foreach (string str2 in from v in list.Distinct <string>() orderby v select v)
{
if (!string.IsNullOrEmpty(str2))
{
this.listBoxControlValues.Items.Add(str2);
}
}
}
}
catch (System.Exception ex)
{
}
}
public FieldSpeaker(IConversationContext context, IField field) : base(context)
=> _field = field;
public static string JsFullName(this IField field)
{
return(field.DeclaringType.JsFullName().Id().Get(field.JsName()).ToString());
}
/// <summary>
/// Export graphics to a shapefile
/// </summary>
/// <param name="fileNamePath">Path to shapefile</param>
/// <param name="graphicsList">List of graphics for selected tab</param>
/// <param name="ipSpatialRef">Spatial Reference being used</param>
/// <returns>Created featureclass</returns>
private IFeatureClass ExportToShapefile(string fileNamePath, List <Graphic> graphicsList, ISpatialReference ipSpatialRef, bool polyLineFC)
{
int index = fileNamePath.LastIndexOf('\\');
string folder = fileNamePath.Substring(0, index);
string nameOfShapeFile = fileNamePath.Substring(index + 1);
string shapeFieldName = "Shape";
IFeatureClass featClass = null;
using (ComReleaser oComReleaser = new ComReleaser())
{
try
{
IWorkspaceFactory workspaceFactory = null;
workspaceFactory = new ShapefileWorkspaceFactoryClass();
IWorkspace workspace = workspaceFactory.OpenFromFile(folder, 0);
IFeatureWorkspace featureWorkspace = workspace as IFeatureWorkspace;
IFields fields = null;
IFieldsEdit fieldsEdit = null;
fields = new Fields();
fieldsEdit = (IFieldsEdit)fields;
IField field = null;
IFieldEdit fieldEdit = null;
field = new FieldClass();///###########
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Shape";
fieldEdit.Type_2 = (esriFieldType.esriFieldTypeGeometry);
IGeometryDef geomDef = null;
IGeometryDefEdit geomDefEdit = null;
geomDef = new GeometryDefClass();///#########
geomDefEdit = (IGeometryDefEdit)geomDef;
if (polyLineFC)
{
geomDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolyline;
}
else
{
geomDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolygon;
}
geomDefEdit.SpatialReference_2 = ipSpatialRef;
fieldEdit.GeometryDef_2 = geomDef;
fieldsEdit.AddField(field);
string graphicsType = graphicsList[0].GraphicType.ToString();
switch (graphicsType)
{
case "Line":
{
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Distance";
fieldEdit.AliasName_2 = "Geodetic Distance";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "DistUnit";
fieldEdit.AliasName_2 = "Distance Unit";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "OriginX";
fieldEdit.AliasName_2 = "Origin X";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "OriginY";
fieldEdit.AliasName_2 = "Origin Y";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "DestX";
fieldEdit.AliasName_2 = "Dest X";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "DestY";
fieldEdit.AliasName_2 = "Dest Y";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Angle";
fieldEdit.AliasName_2 = "Angle";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "AngleUnit";
fieldEdit.AliasName_2 = "Angle Unit";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldsEdit.AddField(field);
break;
}
case "Circle":
{
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Distance";
fieldEdit.AliasName_2 = "Distance";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "DistUnit";
fieldEdit.AliasName_2 = "Distance Unit";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "DistType";
fieldEdit.AliasName_2 = "Distance Type";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "CenterX";
fieldEdit.AliasName_2 = "Center X";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "CenterY";
fieldEdit.AliasName_2 = "Center Y";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
break;
}
case "Ellipse":
{
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "MajAxis";
fieldEdit.AliasName_2 = "Major Axis";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "MinAxis";
fieldEdit.AliasName_2 = "Minor Axis";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "DistUnit";
fieldEdit.AliasName_2 = "Distance Unit";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "CenterX";
fieldEdit.AliasName_2 = "Center X";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "CenterY";
fieldEdit.AliasName_2 = "Center Y";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Angle";
fieldEdit.AliasName_2 = "Angle";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "AngleUnit";
fieldEdit.AliasName_2 = "Angle Unit";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldsEdit.AddField(field);
break;
}
case "RangeRing":
{
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Rings";
fieldEdit.AliasName_2 = "Rings";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Distance";
fieldEdit.AliasName_2 = "Geodetic Distance";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "DistUnit";
fieldEdit.AliasName_2 = "Distance Unit";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Radials";
fieldEdit.AliasName_2 = "Radials";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "CenterX";
fieldEdit.AliasName_2 = "Center X";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
field = new FieldClass();
fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "CenterY";
fieldEdit.AliasName_2 = "Center Y";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;
fieldsEdit.AddField(field);
break;
}
}
featClass = featureWorkspace.CreateFeatureClass(nameOfShapeFile, fields, null, null, esriFeatureType.esriFTSimple, shapeFieldName, "");
foreach (Graphic graphic in graphicsList)
{
if (graphic.Attributes == null)
{
continue;
}
IFeature feature = featClass.CreateFeature();
if (polyLineFC)
{
feature.Shape = graphic.Geometry;
}
else
{
feature.Shape = PolylineToPolygon(graphic.Geometry);
}
switch (graphic.GraphicType.ToString())
{
case "Line":
{
System.Object dist;
System.Object angle;
System.Object angleunit;
System.Object ox;
System.Object oy;
System.Object dx;
System.Object dy;
System.Object distunit;
graphic.Attributes.TryGetValue("distance", out dist);
graphic.Attributes.TryGetValue("distanceunit", out distunit);
graphic.Attributes.TryGetValue("startx", out ox);
graphic.Attributes.TryGetValue("starty", out oy);
graphic.Attributes.TryGetValue("endx", out dx);
graphic.Attributes.TryGetValue("endy", out dy);
graphic.Attributes.TryGetValue("angle", out angle);
graphic.Attributes.TryGetValue("angleunit", out angleunit);
feature.set_Value(feature.Fields.FindField("Distance"), dist);
feature.set_Value(feature.Fields.FindField("DistUnit"), distunit);
feature.set_Value(feature.Fields.FindField("OriginX"), ox);
feature.set_Value(feature.Fields.FindField("OriginY"), oy);
feature.set_Value(feature.Fields.FindField("DestX"), dx);
feature.set_Value(feature.Fields.FindField("DestY"), dy);
feature.set_Value(feature.Fields.FindField("Angle"), angle);
feature.set_Value(feature.Fields.FindField("AngleUnit"), angleunit);
break;
}
case "Circle":
{
System.Object radius;
System.Object disttype;
System.Object distunit;
System.Object centerx;
System.Object centery;
graphic.Attributes.TryGetValue("radius", out radius);
graphic.Attributes.TryGetValue("distanceunit", out distunit);
graphic.Attributes.TryGetValue("disttype", out disttype);
graphic.Attributes.TryGetValue("centerx", out centerx);
graphic.Attributes.TryGetValue("centery", out centery);
feature.set_Value(feature.Fields.FindField("Distance"), radius);
feature.set_Value(feature.Fields.FindField("DistUnit"), distunit);
feature.set_Value(feature.Fields.FindField("DistType"), disttype);
feature.set_Value(feature.Fields.FindField("CenterX"), centerx);
feature.set_Value(feature.Fields.FindField("CenterY"), centery);
break;
}
case "Ellipse":
{
System.Object majoraxis;
System.Object minoraxis;
System.Object angle;
System.Object distunit;
System.Object centerx;
System.Object centery;
System.Object angleunit;
graphic.Attributes.TryGetValue("majoraxis", out majoraxis);
graphic.Attributes.TryGetValue("minoraxis", out minoraxis);
graphic.Attributes.TryGetValue("azimuth", out angle);
graphic.Attributes.TryGetValue("distanceunit", out distunit);
graphic.Attributes.TryGetValue("centerx", out centerx);
graphic.Attributes.TryGetValue("centery", out centery);
graphic.Attributes.TryGetValue("angleunit", out angleunit);
feature.set_Value(feature.Fields.FindField("MajAxis"), majoraxis);
feature.set_Value(feature.Fields.FindField("MinAxis"), minoraxis);
feature.set_Value(feature.Fields.FindField("DistUnit"), distunit);
feature.set_Value(feature.Fields.FindField("Angle"), angle);
feature.set_Value(feature.Fields.FindField("CenterX"), centerx);
feature.set_Value(feature.Fields.FindField("CenterY"), centery);
feature.set_Value(feature.Fields.FindField("AngleUnit"), angleunit);
break;
}
case "RangeRing":
{
System.Object rings;
System.Object distance;
System.Object radials;
System.Object distunit;
System.Object centerx;
System.Object centery;
graphic.Attributes.TryGetValue("rings", out rings);
graphic.Attributes.TryGetValue("distance", out distance);
graphic.Attributes.TryGetValue("radials", out radials);
graphic.Attributes.TryGetValue("distanceunit", out distunit);
graphic.Attributes.TryGetValue("centerx", out centerx);
graphic.Attributes.TryGetValue("centery", out centery);
feature.set_Value(feature.Fields.FindField("Rings"), rings);
feature.set_Value(feature.Fields.FindField("Distance"), distance);
feature.set_Value(feature.Fields.FindField("Radials"), radials);
feature.set_Value(feature.Fields.FindField("DistUnit"), distunit);
feature.set_Value(feature.Fields.FindField("CenterX"), centerx);
feature.set_Value(feature.Fields.FindField("CenterY"), centery);
break;
}
}
feature.Store();
}
IFeatureLayer featurelayer = null;
featurelayer = new FeatureLayerClass();
featurelayer.FeatureClass = featClass;
featurelayer.Name = featClass.AliasName;
System.Runtime.InteropServices.Marshal.FinalReleaseComObject(workspace);
workspace = null;
GC.Collect();
return(featClass);
}
catch (Exception ex)
{
return(featClass);
}
}
}
public static int[] ConvertCoords(this IField field, int num)
{
return(new[] { num % field.Width, num / field.Width });
}
public SelectFieldTransform(IField field)
{
this.field = field;
}
