public static void RelateTableLayer(ILayer pSrcLayer, string pSrcFieldName, ITable pToTable, string pToFieldName)
{
try
{
IAttributeTable table = pSrcLayer as IAttributeTable;
if (table != null)
{
ITable attributeTable = table.AttributeTable;
if (pToTable is IStandaloneTable)
{
pToTable = (pToTable as IStandaloneTable).Table;
}
IMemoryRelationshipClassFactory factory = new MemoryRelationshipClassFactoryClass();
IRelationshipClass relationshipClass = factory.Open("TabletoLayer", (IObjectClass)pToTable,
pToFieldName, (IObjectClass)attributeTable, pSrcFieldName, "forward", "backward",
esriRelCardinality.esriRelCardinalityOneToMany);
((IRelationshipClassCollectionEdit)pSrcLayer).AddRelationshipClass(relationshipClass);
}
}
catch (COMException exception)
{
MessageBox.Show(exception.Message, "COM Error: " + exception.ErrorCode.ToString(), MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
catch (Exception exception2)
{
MessageBox.Show(exception2.Message, ".NET Error: ", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
/// <summary>
/// Gets whether the specified AU is enabled.
/// </summary>
/// <param name="pRelClass">The relationship class.</param>
/// <param name="eEvent">The edit event.</param>
/// <returns><c>true</c> if this AutoUpdater is enabled; otherwise <c>false</c></returns>
public bool get_Enabled(IRelationshipClass pRelClass, mmEditEvent eEvent)
{
try
{
if (pRelClass == null)
{
return(false);
}
return(this.InternalEnabled(pRelClass, pRelClass.OriginClass, pRelClass.DestinationClass, eEvent));
}
catch (Exception e)
{
if (MinerRuntimeEnvironment.IsUserInterfaceSupported)
{
Log.Error("Error Enabling Relationship AU " + Name, e);
}
else
{
Log.Error(e);
}
}
return(false);
}
public static void RelateTableLayer(ILayer ilayer_0, string string_0, ITable itable_0, string string_1)
{
try
{
IAttributeTable table = ilayer_0 as IAttributeTable;
if (table != null)
{
ITable attributeTable = table.AttributeTable;
if (itable_0 is IStandaloneTable)
{
itable_0 = (itable_0 as IStandaloneTable).Table;
}
IMemoryRelationshipClassFactory factory = new MemoryRelationshipClassFactoryClass();
IRelationshipClass relationshipClass = factory.Open("TabletoLayer", (IObjectClass)itable_0,
string_1, (IObjectClass)attributeTable, string_0, "forward", "backward",
esriRelCardinality.esriRelCardinalityOneToMany);
((IRelationshipClassCollectionEdit)ilayer_0).AddRelationshipClass(relationshipClass);
}
}
catch (COMException exception)
{
MessageBox.Show(exception.Message, "COM Error: " + exception.ErrorCode.ToString(), MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
catch (Exception exception2)
{
MessageBox.Show(exception2.Message, ".NET Error: ", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RelationshipClassJoinDefinition"/> class.
/// </summary>
/// <param name="relClass">The relationship class.</param>
/// <param name="joinType">The join type.</param>
/// <param name="baseFeatureClass">The primary feature class containing the shape field
/// in for joins between two feature classes. In the case of an outer join it must not be
/// on the outer side, i.e. no null values must exist in the base feature class side.</param>
internal RelationshipClassJoinDefinition(
[NotNull] IRelationshipClass relClass,
JoinType joinType,
[CanBeNull] IFeatureClass baseFeatureClass = null)
: base(joinType)
{
Assert.ArgumentNotNull(relClass, nameof(relClass));
_relClass = relClass;
if (baseFeatureClass == null)
{
_tableNames = GetTableNames(relClass, out _baseFeatureClass,
out _featureClassCount);
}
else
{
_baseFeatureClass = baseFeatureClass;
Assert.True(IsInvolvedFeatureClass(baseFeatureClass, relClass),
"The base feature class must participate in the relationship class");
_tableNames = GetTableNames(relClass, baseFeatureClass, joinType,
out _featureClassCount);
}
}
/// <summary>
/// Creates relationship classes between the Broadcast feature class and the Voyage and Vessel tables.
/// </summary>
/// <param name="pWorkspace">FileGeodatabase workspace.</param>
public void CreateRelationshipClass(IWorkspace pWorkspace)
{
try
{
if (!(IsArcInfoLicense()))
{
return;
}
IFeatureWorkspace pFWS = (IFeatureWorkspace)pWorkspace;
// Creating a relationship class without an intermediate table.
IObjectClass pOriginClass = (IObjectClass)pFWS.OpenFeatureClass("Broadcast");
IObjectClass pVesselClass = (IObjectClass)pFWS.OpenTable("Vessel");
IObjectClass pVoyageClass = (IObjectClass)pFWS.OpenTable("Voyage");
IRelationshipClass pVesselRClass = pFWS.CreateRelationshipClass("BroadcastHasVessel", pOriginClass, pVesselClass, "Vessel",
"Broadcast", esriRelCardinality.esriRelCardinalityOneToOne, esriRelNotification.esriRelNotificationBoth, false,
false, null, "MMSI", "", "MMSI", "");
IRelationshipClass pVoyageRClass = pFWS.CreateRelationshipClass("BroadcastHasVoyage", pOriginClass, pVoyageClass, "Voyage",
"Broadcast", esriRelCardinality.esriRelCardinalityOneToOne, esriRelNotification.esriRelNotificationBoth, false,
false, null, "VoyageID", "", "VoyageID", "");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
// TODO: Is this a static Utils class? Or does each IAttributes implementation have
// its specific AttributeHarvester? Or will there be a DatasetHarvester/ModelHarvester
// that can create instances of this class (for the right IAttributes implementation)
// in order to more loosely couple them with the domain classes?
//private readonly IAttributes _attributeContainer;
//public AttributeHarvester(IAttributes attributeContainer)
//{
// _attributeContainer = attributeContainer;
//}
#region AttributedAssociation Attribute harvesting
public static void HarvestAttributes([NotNull] AttributedAssociation attributedAssociation)
{
// TODO: support for configurator?
attributedAssociation.ClearAttributeMaps();
using (_msg.IncrementIndentation(
"Harvesting attributes for attributed association {0}", attributedAssociation.Name))
{
const bool allowAlways = true;
IRelationshipClass relationshipClass =
ModelElementUtils.TryOpenFromMasterDatabase(attributedAssociation, allowAlways);
Assert.NotNull(relationshipClass,
"Relationship class not found in model master database: {0}",
attributedAssociation.Name);
var table = (ITable)relationshipClass;
IList <IField> fields = DatasetUtils.GetFields(table);
for (var fieldIndex = 0; fieldIndex < fields.Count; fieldIndex++)
{
IField field = fields[fieldIndex];
AddOrUpdateAttribute(attributedAssociation, field, fieldIndex);
}
DeleteAttributesNotInList(attributedAssociation, fields);
attributedAssociation.ClearAttributeMaps();
}
}
private void listView1_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
{
//在地块图层获得关系类
IFeatureClass pFeatClass = pParcelFeatLayer.FeatureClass;
IObjectClass pObjectClass = pFeatClass as IObjectClass;
IEnumRelationshipClass pEnumRelationshipClass = pObjectClass.get_RelationshipClasses(esriRelRole.esriRelRoleOrigin);
pEnumRelationshipClass.Reset();
IRelationshipClass pRelationshipClass = pEnumRelationshipClass.Next();
IRow pOwnerRow;
IFeature pParcelFeature;
AxMapControl axMap = pMainFrm.getMapControl();
for (int i = 0; i <= pFeatArray.Count - 1; i++)
{
pParcelFeature = pFeatArray.get_Element(i) as IFeature;
ISet pRelatedSet = pRelationshipClass.GetObjectsRelatedToObject(pParcelFeature);
pRelatedSet.Reset();
pOwnerRow = pRelatedSet.Next() as IRow;
if (pOwnerRow != null)
{
if (pOwnerRow.get_Value(pOwnerRow.Fields.FindField("TMK")).ToString() == e.Item.Text)
{
Utility.FlashFeature(pParcelFeature, axMap.ActiveView.FocusMap);
break;
}
}
}
}
private static IFeatureWorkspace CreateTestWorkspace(
[NotNull] string fgdbName,
[NotNull] string fcName, [NotNull] string tableName, [NotNull] string relClassName,
[NotNull] out IFeatureClass fc,
[NotNull] out ITable table,
[NotNull] out IRelationshipClass rc)
{
IFeatureWorkspace ws = TestWorkspaceUtils.CreateTestFgdbWorkspace(fgdbName);
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference(
(int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95, true);
fc = DatasetUtils.CreateSimpleFeatureClass(
ws, fcName, null,
FieldUtils.CreateOIDField(),
FieldUtils.CreateIntegerField("FKEY"),
FieldUtils.CreateShapeField(
"SHAPE", esriGeometryType.esriGeometryPoint,
sref, 1000));
table = DatasetUtils.CreateTable(ws, tableName,
FieldUtils.CreateOIDField(),
FieldUtils.CreateTextField("TEXT", 100));
rc = TestWorkspaceUtils.CreateSimple1NRelationship(
ws, relClassName,
table, (ITable)fc,
table.OIDFieldName, "FKEY");
return(ws);
}
/// <summary>
/// Executes the geoprocessing function using the given array of parameter values.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <param name="trackCancel">The track cancel.</param>
/// <param name="environmentManager">Provides access to all the current environments and settings of the current client.</param>
/// <param name="messages">The messages that are reported to the user.</param>
/// <param name="utilities">
/// The utilities object that provides access to the properties and methods of a geoprocessing
/// objects.
/// </param>
protected override void Execute(Dictionary <string, IGPValue> parameters, ITrackCancel trackCancel, IGPEnvironmentManager environmentManager, IGPMessages messages, IGPUtilities2 utilities)
{
IGPValue value = parameters["in_table"];
IRelationshipClass relClass = utilities.OpenRelationshipClass(value);
if (relClass != null)
{
IMMConfigTopLevel configTopLevel = ConfigTopLevel.Instance;
configTopLevel.Workspace = utilities.GetWorkspace(value);
IGPMultiValue onCreate = (IGPMultiValue)parameters["in_create"];
IGPMultiValue onDelete = (IGPMultiValue)parameters["in_delete"];
var uids = new Dictionary <mmEditEvent, IEnumerable <IUID> >();
uids.Add(mmEditEvent.mmEventRelationshipCreated, onCreate.AsEnumerable().Cast <IGPAutoValue>().Select(o => o.UID));
uids.Add(mmEditEvent.mmEventRelationshipDeleted, onDelete.AsEnumerable().Cast <IGPAutoValue>().Select(o => o.UID));
// Update the list to have these UIDs.
ID8List list = (ID8List)configTopLevel.GetRelationshipClass(relClass);
base.Add(uids, list, messages);
// Commit the changes to the database.
configTopLevel.SaveRelationshipClasstoDB(relClass);
// Success.
parameters["out_results"].SetAsText("true");
}
else
{
// Failure.
parameters["out_results"].SetAsText("false");
}
}
private void processRelates(IFeatureLayer flyr)
{
string res = "";
string destName = "";
string destServer = "";
string destInstance = "";
string destUser = "";
IRelationshipClassCollection relClassColl = (IRelationshipClassCollection)flyr;
IEnumRelationshipClass enumRelClass = relClassColl.RelationshipClasses;
enumRelClass.Reset();
IRelationshipClass relClass = enumRelClass.Next();
while (relClass != null)
{
IDataset dset = (IDataset)relClass;
ITable destTable = (ITable)relClass.DestinationClass;
IDataset dsetDest = (IDataset)destTable;
destName = dsetDest.Name;
destServer = dsetDest.Workspace.ConnectionProperties.GetProperty("server").ToString();
destInstance = dsetDest.Workspace.ConnectionProperties.GetProperty("instance").ToString();
destUser = dsetDest.Workspace.ConnectionProperties.GetProperty("user").ToString();
res = res + "(" + destName + "/" + destServer + "/" + destInstance + "/" + destUser + "/" + relClass.OriginPrimaryKey + "/" + relClass.OriginForeignKey + "/" + dset.BrowseName + ")";
relClass = enumRelClass.Next();
}
relateinfo = res;
}
/// <summary>
/// Join Urban-rural Devide Table
/// </summary>
/// <param name="layer"></param>
/// <param name="year"></param>
/// <author>Shen Yongyuan</author>
/// <date>20091111</date>
public static void JoinDevideTable(ILayer layer, int year, string city)
{
//Add Fields
IFieldsEdit allFields = new FieldsClass();
IFieldEdit field1 = new FieldClass();
field1.Name_2 = "ID";
field1.Type_2 = esriFieldType.esriFieldTypeString;
allFields.AddField(field1);
IFieldEdit field2 = new FieldClass();
field2.Name_2 = Town.Constant.Constant.TmpFieldName;
field2.Type_2 = esriFieldType.esriFieldTypeString;
allFields.AddField(field2);
//Create Table
IWorkspaceFactory workspaceFactory = new InMemoryWorkspaceFactoryClass();
IWorkspaceName workspaceName = workspaceFactory.Create("", "Temporary WorkSpace In Memory", null, 0);
IFeatureWorkspace workspace = ((IName)workspaceName).Open() as IFeatureWorkspace;
ITable table = workspace.CreateTable(Town.Constant.Constant.TmpTableDevide, allFields, null, null, "");
//Import Data
IWorkspaceEdit workspaceEdit = workspace as IWorkspaceEdit;
workspaceEdit.StartEditing(false);
workspaceEdit.StartEditOperation();
ICursor cursor = table.Insert(true);
int fldField1 = cursor.Fields.FindField("ID");
int fldField2 = cursor.Fields.FindField(Town.Constant.Constant.TmpFieldName);
//Query and Import
Dictionary <int, string> devideResult = DataLib.DA_Devide.GetDevideResult(year, city);
foreach (KeyValuePair <int, string> d in devideResult)
{
IRowBuffer buffer = table.CreateRowBuffer();
buffer.set_Value(fldField1, d.Key.ToString());
buffer.set_Value(fldField2, d.Value);
cursor.InsertRow(buffer);
}
cursor.Flush();
workspaceEdit.StartEditOperation();
workspaceEdit.StopEditing(true);
System.Runtime.InteropServices.Marshal.ReleaseComObject(cursor);
//Join
IMemoryRelationshipClassFactory pMemRelFact = new MemoryRelationshipClassFactory();
IFeatureLayer feaLayer = layer as IFeatureLayer;
ITable originTable = feaLayer.FeatureClass as ITable;
IRelationshipClass pRelClass = pMemRelFact.Open("Join", originTable as IObjectClass, "ID",
table as IObjectClass, "ID", "forward", "backward",
esriRelCardinality.esriRelCardinalityOneToOne);
IDisplayRelationshipClass pDispRC = feaLayer as IDisplayRelationshipClass;
pDispRC.DisplayRelationshipClass(null, esriJoinType.esriLeftOuterJoin);
pDispRC.DisplayRelationshipClass(pRelClass, esriJoinType.esriLeftOuterJoin);
}
public ITable OpenRelationshipQuery(IRelationshipClass pRelClass,
bool joinForward,
IQueryFilter pSrcQueryFilter,
ISelectionSet pSrcSelectionSet,
string TargetColumns, bool DoNotPushJoinToDB)
{
throw new NotImplementedException();
}
private static void CanDetect1ToNUnique([NotNull] IFeatureWorkspace workspace)
{
const string uniqueFieldName = "Unique";
ITable tableOrig;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(
uniqueFieldName, esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(
workspace, "Relate1NUnique1", fields);
for (var i = 0; i < 10; i++)
{
IRow row = table.CreateRow();
row.set_Value(1, i);
row.Store();
}
tableOrig = table;
}
ITable tableRel;
{
IFieldsEdit fields = new FieldsClass();
fields.AddField(FieldUtils.CreateOIDField());
fields.AddField(FieldUtils.CreateField(
"Ref", esriFieldType.esriFieldTypeInteger));
ITable table = TestWorkspaceUtils.CreateSimpleTable(
workspace, "Relate1NUnique2", fields);
for (var i = 0; i < 10; i++)
{
IRow row = table.CreateRow();
row.set_Value(1, i);
row.Store();
}
tableRel = table;
}
IRelationshipClass rel =
TestWorkspaceUtils.CreateSimple1NRelationship(workspace,
"rel1NUnique", tableOrig,
tableRel, uniqueFieldName, "Ref");
ITable relTab = TableJoinUtils.CreateQueryTable(rel, JoinType.InnerJoin);
foreach (bool forceInMemoryTableSort in new[] { true, false })
{
var test = new QaUnique(relTab, "Relate1NUnique1." + uniqueFieldName)
{
ForceInMemoryTableSorting = forceInMemoryTableSort
};
var runner = new QaTestRunner(test);
runner.Execute();
AssertUtils.NoError(runner);
}
}
/// <summary>
/// Checks the validity of the <paramref name="relClass" /> is valid to have an intermediate table.
/// </summary>
/// <param name="relClass">The relationship class.</param>
/// <returns>
/// Returns a <see cref="bool" /> representing if the relationship class is valid.
/// </returns>
private bool CheckValidity(IRelationshipClass relClass)
{
if (relClass.Cardinality != esriRelCardinality.esriRelCardinalityManyToMany || !relClass.IsAttributed)
{
return(false);
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="IntermediateRelationship" /> class.
/// </summary>
/// <param name="relClass">The relationship class.</param>
/// <exception cref="System.ArgumentException">
/// The relationship must either have attributes or many to many
/// cardinality.;relClass
/// </exception>
public IntermediateRelationship(IRelationshipClass relClass)
{
if (!CheckValidity(relClass))
{
throw new ArgumentException(@"The relationship must either have attributes or many to many cardinality.", "relClass");
}
this.RelationshipClass = relClass;
}
private static IUniqueValueRenderer GenerateUniqueValueRenderer(IFeatureLayer featureLayer)
{
IFeatureWorkspace featureWorkspace = ((IDataset)featureLayer.FeatureClass).Workspace as IFeatureWorkspace;
ITable table = featureWorkspace.OpenTable(TableName);
string relClassName = string.Format("{0}_{1}", ((IDataset)featureLayer.FeatureClass).Name, ((IDataset)table).Name);
IRelationshipClass relClass = featureWorkspace.OpenRelationshipClass(relClassName);
IDisplayRelationshipClass displayRelClass = featureLayer as IDisplayRelationshipClass;
if (displayRelClass == null)
{
return(null);
}
displayRelClass.DisplayRelationshipClass(relClass, esriJoinType.esriLeftOuterJoin);
IUniqueValueRenderer uvRenderer = new UniqueValueRendererClass {
FieldCount = 1
};
uvRenderer.Field[0] = string.Format("{0}.{1}", ((IDataset)table).Name, JoinField);
IFeatureCursor cursor = ((IGeoFeatureLayer)featureLayer).SearchDisplayFeatures(null, true);
DataStatisticsClass dataStatistics = new DataStatisticsClass
{
Field = uvRenderer.Field[0],
Cursor = cursor as ICursor
};
IEnumerator pEnumerator = dataStatistics.UniqueValues;
pEnumerator.Reset();
Random random = new Random();
while (pEnumerator.MoveNext())
{
string value = Convert.ToString(pEnumerator.Current);
RgbColorClass fillColor = new RgbColorClass
{
Red = random.Next(0, 255),
Green = random.Next(0, 255),
Blue = random.Next(0, 255)
};
SimpleFillSymbolClass fillSymbol = new SimpleFillSymbolClass {
Color = fillColor
};
uvRenderer.AddValue(value, "ZONE", fillSymbol);
}
Marshal.ReleaseComObject(cursor);
return(uvRenderer);
}
/// <summary>
/// Initializes a new instance of the <see cref="IntermediateRow" /> struct.
/// </summary>
/// <param name="row">The row.</param>
/// <param name="relClass">The relationship class.</param>
public IntermediateRow(IRow row, IRelationshipClass relClass)
{
this.Row = row;
this.Items = new Dictionary <string, object>();
ITable table = (ITable)relClass;
this.OriginForeignKey = TypeCast.Cast(row.get_Value(table.FindField(relClass.OriginForeignKey)), string.Empty);
this.DestinationForeignKey = TypeCast.Cast(row.get_Value(table.FindField(relClass.DestinationForeignKey)), string.Empty);
}
/// <summary>
/// 获取与标注对应的关联设备
/// </summary>
/// <param name="pAnnoFeature"></param>
/// <returns></returns>
public static IFeature GetLinkedFeature(IAnnotationFeature2 pAnnoFeature)
{
// 方法一
IFeature pFeature = (IFeature)pAnnoFeature;
IFeatureClass pfClass = (IFeatureClass)pFeature.Class;
IEnumRelationshipClass pEnumRelation =
pfClass.get_RelationshipClasses(esriRelRole.esriRelRoleAny);
IRelationshipClass pRelationship = pEnumRelation.Next();
if (pRelationship == null)
{
return(null);
}
ISet pSet = pRelationship.GetObjectsRelatedToObject(pFeature);
if (pSet == null)
{
return(null);
}
object o = pSet.Next();
if (o == null || !(o is IFeature))
{
return(null);
}
pFeature = (IFeature)o;
return(pFeature);
// 方法二
/*
* IFeature pFeature = (IFeature)pAnnoFeature;
* IFeatureClass pfClass = (IFeatureClass)pFeature.Class;
* IEnumRelationshipClass enumRelCls =
* pfClass.get_RelationshipClasses(esriRelRole.esriRelRoleAny);
* IRelationshipClass pRelationship = enumRelCls.Next();
* if (pRelationship == null)
* return null;
*
* // 注记的FeatureClass
* IFeatureClass pDestionClass = (IFeatureClass)pRelationship.OriginClass;
* if (pDestionClass == null)
* return null;
*
* string foreignKey = pRelationship.DestinationPrimaryKey;
* if (string.IsNullOrEmpty(foreignKey))
* return null;
*
* pFeature = pDestionClass.GetFeature(pAnnoFeature.LinkedFeatureID);
* return pFeature;
*/
}
private static void TestNMRelation(IFeatureWorkspace ws)
{
IFieldsEdit fields1 = new FieldsClass();
fields1.AddField(FieldUtils.CreateOIDField());
fields1.AddField(FieldUtils.CreateIntegerField("Pk"));
ITable tbl1 = DatasetUtils.CreateTable(ws, "TestNMRelation1", null, fields1);
IFieldsEdit fields2 = new FieldsClass();
fields2.AddField(FieldUtils.CreateOIDField());
fields2.AddField(FieldUtils.CreateIntegerField("Fk"));
ITable tbl2 = DatasetUtils.CreateTable(ws, "TestNMRelation2", null, fields2);
IRelationshipClass rel = CreateSimpleMNRelationship(ws, "TestNMRelationRel", tbl1,
tbl2, "Pk", "Fk");
((IWorkspaceEdit)ws).StartEditing(false);
IRow r11 = CreateRow(tbl1, 8);
IRow r12 = CreateRow(tbl1, 12);
IRow r13 = CreateRow(tbl1, 7);
IRow r21 = CreateRow(tbl2, 9);
IRow r22 = CreateRow(tbl2, 5);
IRow r23 = CreateRow(tbl2, 4);
Assert.NotNull(r12); // not used otherwise
rel.CreateRelationship((IObject)r11, (IObject)r21);
rel.CreateRelationship((IObject)r11, (IObject)r23);
rel.CreateRelationship((IObject)r13, (IObject)r22);
r22.set_Value(1, 6);
r22.Store();
((IWorkspaceEdit)ws).StopEditing(true);
var test = new QaUnreferencedRows(tbl1,
new[] { tbl2 },
new[] { "pk,pk,TestNMRelationRel,fk,fk" });
using (var r = new QaTestRunner(test))
{
r.Execute();
Assert.AreEqual(2, r.Errors.Count);
}
var container = new QaContainerTestRunner(10000, test);
container.Execute();
Assert.AreEqual(2, container.Errors.Count);
}
/// <summary>
/// Returns the many to many relationship (or intermediate table) that resides in between the origin and destination
/// classes.
/// </summary>
/// <param name="source">The relationship class that participates in a many to many relationship.</param>
/// <returns>
/// Returns a <see cref="IIntermediateRelationship" /> representing the intermediate table (or many to many
/// relationship) that resides between
/// the many to many relationship.
/// </returns>
public static IIntermediateRelationship GetIntermediateRelationship(this IRelationshipClass source)
{
if (source == null)
{
return(null);
}
IIntermediateRelationship o = new IntermediateRelationship(source);
return(o);
}
private static ObjectAttribute GetOriginFK([NotNull] IRelationshipClass relClass,
[NotNull] IObjectDataset objectDataset)
{
ObjectAttribute originFK = objectDataset.GetAttribute(relClass.OriginForeignKey);
Assert.NotNull(originFK, "origin foreign key not found on dataset {0}: {1}",
objectDataset.Name,
relClass.OriginForeignKey);
return(originFK);
}
/// <summary>
/// Implementation of enabled method for derived classes.
/// </summary>
/// <param name="relClass">The relelationship class.</param>
/// <param name="originClass">The origin class.</param>
/// <param name="destClass">The destination class.</param>
/// <param name="editEvent">The edit event.</param>
/// <returns>
/// <c>true</c> if this AutoUpdater is enabled; otherwise <c>false</c>
/// </returns>
/// <remarks>
/// This method will be called from IMMRelationshipAUStrategyEx::get_Enabled
/// and is wrapped within the exception handling for that method.
/// </remarks>
protected override bool InternalEnabled(IRelationshipClass relClass, IObjectClass originClass, IObjectClass destClass, mmEditEvent editEvent)
{
foreach (IMMRelationshipAUStrategy item in this.Items)
{
if (!item.get_Enabled(relClass, editEvent))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Creates a new relationship between the two specified objects.
/// </summary>
/// <param name="source">The relationship class that participates in a many to many relationship.</param>
/// <param name="originObject">The origin object.</param>
/// <param name="destinationObject">The destination object.</param>
/// <param name="mode">The mode.</param>
/// <returns>
/// Returns a <see cref="IRelationship" /> representing the relationship between the two objects.
/// </returns>
public static IRelationship CreateRelationship(this IRelationshipClass source, IObject originObject, IObject destinationObject, mmAutoUpdaterMode mode)
{
if (source == null)
{
return(null);
}
using (new AutoUpdaterModeReverter(mode))
{
return(source.CreateRelationship(originObject, destinationObject));
}
}
public static Association CreateAssociation(
[NotNull] IRelationshipClass relClass,
[NotNull] IObjectDataset destinationDataset,
[NotNull] IObjectDataset originDataset,
[NotNull] Model model)
{
bool unqualifyDatasetName = !model.HarvestQualifiedElementNames;
string relClassName = DatasetUtils.GetName(relClass);
AssociationCardinality cardinality = GetCardinality(relClass);
ObjectAttribute originPK = GetOriginPK(relClass, originDataset);
string associationName = !unqualifyDatasetName
? relClassName
: ModelElementNameUtils.GetUnqualifiedName(relClassName);
if (!relClass.IsAttributed &&
relClass.Cardinality != esriRelCardinality.esriRelCardinalityManyToMany)
{
ObjectAttribute originFK = GetOriginFK(relClass,
destinationDataset);
return(new ForeignKeyAssociation(associationName,
cardinality,
originFK,
originPK)
{
Model = model
});
}
ObjectAttribute destinationPK = GetDestinationPK(
relClass, destinationDataset);
var relTable = (ITable)relClass;
esriFieldType destinationFKType = DatasetUtils.GetField(
relTable,
relClass.DestinationForeignKey).Type;
esriFieldType originFKType = DatasetUtils.GetField(
relTable, relClass.OriginForeignKey).Type;
return(new AttributedAssociation(
associationName,
cardinality,
relClass.DestinationForeignKey, (FieldType)destinationFKType,
destinationPK,
relClass.OriginForeignKey, (FieldType)originFKType,
originPK)
{
Model = model
});
}
/// <summary>
/// This function use the "OpenRelationshipClass" function to open a relationship class in the passed in workspace. Then the relationship class uses the
/// "GetObjectsRelated" to return an ISet of the objects that are related to the specified input object.
/// </summary>
/// <param name="relatedTable">the relateionship table</param>
/// <param name="obj">the object to find relationships for</param>
/// <param name="fws">the feature workspace to work in</param>
/// <returns>ISet of all relationships for passed in object</returns>
public static ISet PerformRelatedObjectQuery(string relatedTable, IObject obj, IFeatureWorkspace fws)
{
try
{
IRelationshipClass pRelClass = fws.OpenRelationshipClass(relatedTable);
return(pRelClass.GetObjectsRelatedToObject(obj));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void Refresh()
{
TableList.Clear();
RelationLookup.Clear();
IMap aMap = ArcMap.Document.FocusMap as IMap;
IMapLayers2 layers = ArcMap.Document.FocusMap as IMapLayers2;
IEnumLayer someLayers = layers.Layers;
ILayer aLayer = null;
while ((aLayer = someLayers.Next()) != null)
{
IFeatureLayer2 someFeatlayer = aLayer as IFeatureLayer2;
if (someFeatlayer != null)
{
IFeatureClass featClass = someFeatlayer.FeatureClass as IFeatureClass;
if (featClass != null)
{
IEnumRelationshipClass someRelationships = featClass.RelationshipClasses[esriRelRole.esriRelRoleAny] as IEnumRelationshipClass;
if (someRelationships != null)
{
IRelationshipClass aRelationship = someRelationships.Next();
while (aRelationship != null)
{
Debug.WriteLine(aRelationship.OriginClass.AliasName + " <--> " + aRelationship.DestinationClass.AliasName);
IDataset aDataset = aRelationship.OriginClass as IDataset;
IDataset anotherDataset = aRelationship.DestinationClass as IDataset;
AddDataset(new IDataset[] { aDataset, anotherDataset });
IDataset aDS = featClass as IDataset;
if (aDS != null)
{
Debug.WriteLine(aDS.Name + "," + aDataset.Name + "," + anotherDataset.Name);
string name = aDS.Name.Equals(aDataset.Name, StringComparison.InvariantCultureIgnoreCase) ? anotherDataset.Name : aDataset.Name;
if (RelationLookup.ContainsKey(name))
{
RelationLookup[name].Add(aRelationship);
}
else
{
RelationLookup.Add(name, new List <IRelationshipClass>()
{
aRelationship
});
}
}
aRelationship = someRelationships.Next();
}
}
}
}
}
TableList.Sort((a, b) => a.TableName.CompareTo(b.TableName));
}
/// <summary>
/// 获取与要素设置的releationshipclss对应的标注要素
/// </summary>
/// <param name="pFeature">地图要素</param>
/// <returns>标注要素</returns>
public static IAnnotationFeature2 GetLinkedFeature(IFeature pFeature)
{
// 方法一
IFeatureClass pfClass = (IFeatureClass)pFeature.Class;
IEnumRelationshipClass pEnumRelation =
pfClass.get_RelationshipClasses(esriRelRole.esriRelRoleAny);
IRelationshipClass pRelationship = pEnumRelation.Next();
if (pRelationship == null)
{
return(null);
}
ISet pSet = pRelationship.GetObjectsRelatedToObject(pFeature);
if (pSet == null)
{
return(null);
}
object o = pSet.Next();
if (o == null || !(o is IAnnotationFeature2))
{
return(null);
}
IAnnotationFeature2 pAnnoFeature = (IAnnotationFeature2)o;
return(pAnnoFeature);
/*
* 方法二
*
* // 注记的FeatureClass
* IFeatureClass pDestionClass = (IFeatureClass)pRelationship.DestinationClass;
* if (pDestionClass == null)
* return null;
*
* string foreignKey = pRelationship.OriginForeignKey;
* if (string.IsNullOrEmpty(foreignKey))
* return null;
*
* string where = foreignKey + "='" + pFeature.OID + "'";
* IAnnotationFeature2 pAnnoFeature =
* (IAnnotationFeature2)GeometryHelper.SearchFeature(pDestionClass, where);
*
* return pAnnoFeature;
*/
}
/// <summary>
/// Creates an <see cref="IEnumerable{T}" /> from an <see cref="IEnumRelationshipClass" />
/// </summary>
/// <param name="source">An <see cref="IEnumRelationshipClass" /> to create an <see cref="IEnumerable{T}" /> from.</param>
/// <returns>An <see cref="IEnumerable{T}" /> that contains the relationship classes from the input source.</returns>
public static IEnumerable <IRelationshipClass> AsEnumerable(this IEnumRelationshipClass source)
{
if (source != null)
{
source.Reset();
IRelationshipClass relationshipClass = source.Next();
while (relationshipClass != null)
{
yield return(relationshipClass);
relationshipClass = source.Next();
}
}
}
private static ObjectAttribute GetDestinationPK(
[NotNull] IRelationshipClass relClass,
[NotNull] IObjectDataset objectDataset)
{
ObjectAttribute destinationPK =
objectDataset.GetAttribute(relClass.DestinationPrimaryKey);
Assert.NotNull(destinationPK,
"destination primary key not found on dataset {0}: {1}",
objectDataset.Name,
relClass.DestinationPrimaryKey);
return(destinationPK);
}
private void method_2(IDisplayRelationshipClass idisplayRelationshipClass_0, IRelQueryTable irelQueryTable_0)
{
try
{
IRelationshipClass relationshipClass = irelQueryTable_0.RelationshipClass;
if (relationshipClass != null)
{
idisplayRelationshipClass_0.DisplayRelationshipClass(relationshipClass,
idisplayRelationshipClass_0.JoinType);
}
}
catch
{
}
}
void IRelationshipClassCollectionEdit.RemoveRelationshipClass(IRelationshipClass RelationshipClass)
{
((IRelationshipClassCollectionEdit)featureLayer).RemoveRelationshipClass(RelationshipClass);
}
private void populate(IFeature src, IFeature dest, IRelationshipClass rc, string[] fnames)
{
// the rc is 1-1
ISet st = rc.GetObjectsRelatedToObject(src);
if(st.Count!=1)
{
Logger.Write("Join not found for "+((IDataset)rc).Name);
return;
}
IRow row = (IRow)st.Next();
// extract the fields
for(int i=0;i<fnames.Length;i++)
{
int index = dest.Fields.FindField(fnames[i]);
int index2 = row.Fields.FindField(fnames[i]);
if(index > -1 && index2 > -1)
{
dest.set_Value(index,row.get_Value(index2));
}
}
}
void IDisplayRelationshipClass.DisplayRelationshipClass(IRelationshipClass relClass, esriJoinType JoinType)
{
((IDisplayRelationshipClass)featureLayer).DisplayRelationshipClass(relClass, JoinType);
}
public ITable OpenRelationshipQuery(IRelationshipClass pRelClass, bool joinForward, IQueryFilter pSrcQueryFilter, ISelectionSet pSrcSelectionSet, string TargetColumns, bool DoNotPushJoinToDB)
{
// I don't think this needs to be implemented for now.
throw new NotImplementedException();
}
void IJoin.Perform()
{
_relClassEdit = (IRelationshipClassCollectionEdit)_featureLayer;
_relClassEdit.RemoveAllRelationshipClasses();
_geoFeatureLayer = (IGeoFeatureLayer)_featureLayer;
_dspRel = (IDisplayRelationshipClass)_geoFeatureLayer;
_memRelFact = new MemoryRelationshipClassFactoryClass();
IObjectClass tblObj = (IObjectClass)_table;
_relClass = _memRelFact.Open("test", _geoFeatureLayer.FeatureClass, _joinFieldOnLayer, tblObj, _joinFieldOnTable,
"Forwards", "Backwards", _cardinality);
_dspRel.DisplayRelationshipClass(_relClass, _type);
}
