internal object GetMemberIndex(MetaDataMember member)
{
MetaDataTable table = tablesHeap.GetTable(member.Table);
uint index = (uint)(member.metadatatoken - ((uint)table.Type << 24));
return(ProcessIndex(table, index));
}
internal override void RefreshMember(MetaDataMember mm, RefreshMode mode, object freshValue)
{
if ((mode != RefreshMode.KeepCurrentValues) &&
(!HasChangedValue(mm) || (mode == RefreshMode.OverwriteCurrentValues)))
{
object boxedValue = mm.StorageAccessor.GetBoxedValue(current);
if (!Equals(freshValue, boxedValue))
{
mm.StorageAccessor.SetBoxedValue(ref current, freshValue);
foreach (MetaDataMember member in GetAssociationsForKey(mm))
{
if (!member.Association.IsMany)
{
IEnumerable source =
tracker.services.GetDeferredSourceFactory(member).CreateDeferredSource(
current);
if (member.StorageAccessor.HasValue(current))
{
AssignMember(current, member,
source.Cast <object>().SingleOrDefault());
}
}
}
}
}
}
// Ensure the the member and foreign keys are nulled so that after trackedInstance is deleted,
// the object does not appear to be associated with the other side anymore. This prevents the deleted object
// from referencing objects still in the cache, but also will prevent the related object from being implicitly loaded
private static void ClearForeignKeysHelper(MetaAssociation assoc, object trackedInstance)
{
Debug.Assert(assoc.IsForeignKey, "Foreign key clearing should only happen on foreign key side of the association.");
Debug.Assert(assoc.ThisMember.IsAssociation, "Expected ThisMember of an association to always be an association.");
// If this member is one of our deferred loaders, and it does not already have a value, explicitly set the deferred source to
// null so that when we set the association member itself to null later, it doesn't trigger an implicit load.
// This is only necessary if the value has not already been assigned or set, because otherwise we won't implicitly load anyway when the member is accessed.
MetaDataMember thisMember = assoc.ThisMember;
if (thisMember.IsDeferred &&
!(thisMember.StorageAccessor.HasAssignedValue(trackedInstance) || thisMember.StorageAccessor.HasLoadedValue(trackedInstance)))
{
// If this is a deferred member, set the value directly in the deferred accessor instead of going
// through the normal member accessor, so that we don't trigger an implicit load.
thisMember.DeferredSourceAccessor.SetBoxedValue(ref trackedInstance, null);
}
// Notify the object that the relationship should be considered deleted.
// This allows the object to do its own fixup even when we can't do it automatically.
thisMember.MemberAccessor.SetBoxedValue(ref trackedInstance, null);
// Also set the foreign key values to null if possible
for (int i = 0, n = assoc.ThisKey.Count; i < n; i++)
{
MetaDataMember thisKey = assoc.ThisKey[i];
if (thisKey.CanBeNull)
{
thisKey.StorageAccessor.SetBoxedValue(ref trackedInstance, null);
}
}
}
internal override bool HasChangedValue(MetaDataMember mm)
{
if (current != original)
{
if (mm.IsAssociation && mm.Association.IsMany)
{
return(mm.StorageAccessor.HasAssignedValue(original));
}
if (mm.StorageAccessor.HasValue(current))
{
if ((original != null) && mm.StorageAccessor.HasValue(original))
{
Debug.Assert(mm.Ordinal < dirtyMemberCache.Count);
if (dirtyMemberCache.Get(mm.Ordinal))
{
return(true);
}
object boxedValue = mm.MemberAccessor.GetBoxedValue(original);
return(!Equals(mm.MemberAccessor.GetBoxedValue(current), boxedValue));
}
if (mm.IsDeferred && mm.StorageAccessor.HasAssignedValue(current))
{
return(true);
}
}
}
return(false);
}
protected override SqlExpression GetInsertIdentityExpression(MetaDataMember member)
{
var exp = new SqlVariable(member.Type, typeProvider.From(member.Type),
"NEXT VALUE FOR " + FirebirdSqlBuilder.GetSequenceName(member), dominatingExpression);
return(exp);
}
protected override SqlExpression GetInsertIdentityExpression(MetaDataMember member)
{
var exp = new SqlVariable(member.Type, typeProvider.From(member.Type),
OracleSqlBuilder.GetSequenceName(member, translator.Provider.SqlIdentifier) + ".NEXTVAL", dominatingExpression);
return(exp);
}
/// <summary>
/// Returns a list of keys from the given meta type based on the key list string.
/// </summary>
/// <param name="keyListString">The key list string.</param>
/// <param name="parentType">Type of the parent.</param>
/// <returns></returns>
private static ReadOnlyCollection <MetaDataMember> GetKeys(string keyListString, MetaType parentType)
{
if (keyListString != null)
{
var thisKeyList = new List <MetaDataMember>();
string[] keyNames = keyListString.Split(STRING_SEPERATOR, StringSplitOptions.RemoveEmptyEntries);
foreach (string rawKeyName in keyNames)
{
string keyName = rawKeyName.Trim();
//TODO: maybe speed the lookup up
MetaDataMember key = (from dataMember in parentType.PersistentDataMembers
where dataMember.Name == keyName
select dataMember).SingleOrDefault();
if (key == null)
{
string errorMessage = string.Format("Could not find key member '{0}' of key '{1}' on type '{2}'. The key may be wrong or the field or property on '{2}' has changed names.",
keyName, keyListString, parentType.Type.Name);
throw new InvalidOperationException(errorMessage);
}
thisKeyList.Add(key);
}
return(new ReadOnlyCollection <MetaDataMember>(thisKeyList));
}
else //Key is the primary key of this table
{
return(parentType.IdentityMembers);
}
}
public static bool Exists(this DataContext context,
object dataObject, string[] fields, object[] values)
{
MetaTable table = context.Mapping.GetTable(dataObject.GetType());
//检查值是否和字段配对
if (fields.Length != values.Length)
{
throw new ArgumentException("length of fields and values mismatched..");
}
string sql = string.Format(
"SELECT 1 FROM [{0}] WHERE 1=1", table.TableName);
int index = 0;
foreach (string fieldName in fields)
{
MetaDataMember member =
table.RowType.PersistentDataMembers.Single(m => m.Name == fieldName);
sql += string.Format(" AND [{0}] = {{{1}}}", member.MappedName, index.ToString());
index++;
}
sql = string.Format(
"IF EXISTS ({0}) SELECT 1 ELSE SELECT 0", sql);
int count =
context.ExecuteQuery <int>(sql, values).Single();
return(count > 0);
}
public string CreateTableSQL(
MetaTable table)
{
StringBuilder sqlText = new StringBuilder();
sqlText.AppendFormat("CREATE TABLE {0}(\r\n", table.TableName);
for (int memberIndex = 0; memberIndex < table.RowType.DataMembers.Count; memberIndex++)
{
MetaDataMember member = table.RowType.DataMembers[memberIndex];
bool isLastColomn = memberIndex >= table.RowType.DataMembers.Count - 1;
if (!member.IsAssociation)
{
sqlText.AppendFormat("\t{0}{1}\r\n",
CreateColomnSQL(table, member),
isLastColomn ? "" : ",");
}
}
// TODO: Foreign key associations
sqlText.Append(");\r\n");
return(sqlText.ToString());
}
internal static Expression WhereClauseFromSourceAndKeys(Expression source, MetaDataMember[] keyMembers, Expression [] keyValues)
{
Type elementType = TypeSystem.GetElementType(source.Type);
ParameterExpression p = Expression.Parameter(elementType, "p");
Expression whereExpression = null;
for (int i = 0; i < keyMembers.Length; i++)
{
MetaDataMember metaMember = keyMembers[i];
Expression parameterAsDeclaring = elementType == metaMember.Member.DeclaringType ?
(Expression)p : (Expression)Expression.Convert(p, metaMember.Member.DeclaringType);
Expression memberExpression = (metaMember.Member is FieldInfo)
? Expression.Field(parameterAsDeclaring, (FieldInfo)metaMember.Member)
: Expression.Property(parameterAsDeclaring, (PropertyInfo)metaMember.Member);
Expression keyValue = keyValues[i];
if (keyValue.Type != memberExpression.Type)
{
keyValue = Expression.Convert(keyValue, memberExpression.Type);
}
Expression memberEqualityExpression = Expression.Equal(memberExpression, keyValue);
whereExpression = (whereExpression != null)
? Expression.And(whereExpression, memberEqualityExpression)
: memberEqualityExpression;
}
Expression sequenceExpression = Expression.Call(typeof(Enumerable), "Where", new Type[] { p.Type }, source, Expression.Lambda(whereExpression, p));
return(sequenceExpression);
}
private void tablesTree_AfterSelect(object sender, TreeViewEventArgs e)
{
dataGridView.Rows.Clear();
if (e.Node.Tag is MetaDataTable)
{
MetaDataTable table = e.Node.Tag as MetaDataTable;
if (e.Node.Nodes.Count == 1 && e.Node.Nodes[0].Text == "Loading...")
{
e.Node.Nodes.Clear();
TreeNode[] subNodes = new TreeNode[table.Members.Count];
for (int i = 0; i < subNodes.Length; i++)
{
subNodes[i] = CreateTreeNode(table.Members[i]);
}
tablesTree.BeginUpdate();
e.Node.Nodes.AddRange(subNodes);
tablesTree.EndUpdate();
}
}
else if (e.Node.Tag is MetaDataMember)
{
currentMember = (MetaDataMember)e.Node.Tag;
propertyGrid.SelectedObject = currentMember;
SetMetaDataRow(currentMember.MetaDataRow);
}
}
// Sets the value of the given property on the object.
void IUpdatable.SetValue(object targetResource, string propertyName, object propertyValue)
{
MetaTable table = Mapping.GetTable(targetResource.GetType());
MetaDataMember member = table.RowType.DataMembers.Single(x => x.Name == propertyName);
member.MemberAccessor.SetBoxedValue(ref targetResource, propertyValue);
}
private void SetAssociationKeyInfo(MetaAssociation association)
{
DLinqColumnProvider column = (DLinqColumnProvider)FromColumn;
List <string> foreignKeyNames = new List <string>();
int count = column.Member.Association.ThisKey.Count;
for (int i = 0; i < count; i++)
{
MetaDataMember thisKeyMetaDataMember = column.Member.Association.ThisKey[i];
MetaDataMember otherKeyMetaDataMember = column.Member.Association.OtherKey[i];
DLinqColumnProvider thisEntityMemberComponent = FindColumn(column.Table, thisKeyMetaDataMember.Name);
if (ShouldRemoveThisAssociation(association))
{
column.ShouldRemove = true;
return;
}
foreignKeyNames.Add(thisEntityMemberComponent.Name);
if (thisEntityMemberComponent.IsPrimaryKey)
{
IsPrimaryKeyInThisTable = true;
}
if (association.IsForeignKey)
{
thisEntityMemberComponent.IsForeignKeyComponent = true;
}
}
ForeignKeyNames = new ReadOnlyCollection <string>(foreignKeyNames);
}
internal override bool HasChangedValue(MetaDataMember mm)
{
if (current == original)
{
return(false);
}
if (mm.IsAssociation && mm.Association.IsMany)
{
return(mm.StorageAccessor.HasAssignedValue(original));
}
if (mm.StorageAccessor.HasValue(current))
{
if (original != null && mm.StorageAccessor.HasValue(original))
{
if (dirtyMemberCache.Get(mm.Ordinal))
{
return(true);
}
var boxedValue = mm.MemberAccessor.GetBoxedValue(original);
var boxedValue2 = mm.MemberAccessor.GetBoxedValue(current);
if (!object.Equals(boxedValue2, boxedValue))
{
return(true);
}
return(false);
}
if (mm.IsDeferred && mm.StorageAccessor.HasAssignedValue(current))
{
return(true);
}
}
return(false);
}
internal override bool IsMemberPendingGeneration(MetaDataMember keyMember)
{
if (IsNew && keyMember.IsDbGenerated)
{
return(true);
}
foreach (var association in type.Associations)
{
if (association.IsForeignKey)
{
var num = association.ThisKey.IndexOf(keyMember);
if (num > -1)
{
object obj = null;
obj = ((!association.ThisMember.IsDeferred) ? association.ThisMember.StorageAccessor.GetBoxedValue(current) : association.ThisMember.DeferredValueAccessor.GetBoxedValue(current));
if (obj != null && !association.IsMany)
{
var standardTrackedObject = (StandardTrackedObject)tracker.GetTrackedObject(obj);
if (standardTrackedObject != null)
{
var keyMember2 = association.OtherKey[num];
return(standardTrackedObject.IsMemberPendingGeneration(keyMember2));
}
}
}
}
}
return(false);
}
public SqlExpression BuildProjection(SqlExpression item, MetaType rowType, bool allowDeferred, SqlLink link, Expression source)
{
if (!rowType.HasInheritance)
{
return(BuildProjectionInternal(item, rowType, (rowType.Table != null) ? rowType.PersistentDataMembers : rowType.DataMembers, allowDeferred, link, source));
}
var list = new List <MetaType>(rowType.InheritanceTypes);
var list2 = new List <SqlTypeCaseWhen>();
SqlTypeCaseWhen when = null;
MetaType inheritanceRoot = rowType.InheritanceRoot;
MetaDataMember discriminator = inheritanceRoot.Discriminator;
Type type = discriminator.Type;
SqlMember member2 = sql.Member(item, discriminator.Member);
foreach (MetaType type3 in list)
{
if (type3.HasInheritanceCode)
{
SqlNew typeBinding = BuildProjectionInternal(item, type3, type3.PersistentDataMembers, allowDeferred, link, source);
if (type3.IsInheritanceDefault)
{
when = new SqlTypeCaseWhen(null, typeBinding);
}
object obj2 = InheritanceRules.InheritanceCodeForClientCompare(type3.InheritanceCode, member2.SqlType);
SqlExpression match = sql.Value(type, sql.Default(discriminator), obj2, true, source);
list2.Add(new SqlTypeCaseWhen(match, typeBinding));
}
}
if (when == null)
{
throw Error.EmptyCaseNotSupported();
}
list2.Add(when);
return(sql.TypeCase(inheritanceRoot.Type, inheritanceRoot, member2, list2.ToArray(), source));
}
private SqlLink BuildLink(SqlExpression item, MetaDataMember member, Expression source)
{
if (member.IsAssociation)
{
var expressionArray = new SqlExpression[member.Association.ThisKey.Count];
int index = 0;
int length = expressionArray.Length;
while (index < length)
{
MetaDataMember member2 = member.Association.ThisKey[index];
expressionArray[index] = sql.Member(item, member2.Member);
index++;
}
return(new SqlLink(new object(), member.Association.OtherType, member.Type, typeProvider.From(member.Type), item, member, expressionArray, null, source));
}
MetaType declaringType = member.DeclaringType;
var keyExpressions = new List <SqlExpression>();
foreach (MetaDataMember member3 in declaringType.IdentityMembers)
{
keyExpressions.Add(sql.Member(item, member3.Member));
}
return(new SqlLink(new object(), declaringType, member.Type, typeProvider.From(member.Type),
item, member, keyExpressions, sql.Member(item, member.Member), source));
}
private SqlLink BuildLink(SqlExpression item, MetaDataMember member, Expression source)
{
if (member.IsAssociation)
{
var array = new SqlExpression[member.Association.ThisKey.Count];
var i = 0;
for (var num = array.Length; i < num; i++)
{
var metaDataMember = member.Association.ThisKey[i];
array[i] = sql.Member(item, metaDataMember.Member);
}
var otherType = member.Association.OtherType;
return(new SqlLink(new object(), otherType, member.Type, typeProvider.From(member.Type), item, member, array, null, source));
}
var declaringType = member.DeclaringType;
var list = new List <SqlExpression>();
foreach (var identityMember in declaringType.IdentityMembers)
{
list.Add(sql.Member(item, identityMember.Member));
}
SqlExpression expansion = sql.Member(item, member.Member);
return(new SqlLink(new object(), declaringType, member.Type, typeProvider.From(member.Type), item, member, list, expansion, source));
}
public override void UpdateProperty(Guid id, string propertyName, object value)
{
try
{
using IDbConnection connection = m_dbProviderFactory.CreateConnection();
connection.ConnectionString = m_dbConnectionStr;
connection.Open();
IDbCommand updateCommand = connection.CreateCommand();
MetaDataMember member = m_objectMapper.GetMember(propertyName);
string parameterName = "1";
DbParameter dbParameter = base.GetParameter(m_dbProviderFactory, member, value, parameterName);
updateCommand.Parameters.Add(dbParameter);
updateCommand.CommandText = "update " + m_objectMapper.TableName + " set " + propertyName + " = ?" +
parameterName + " where id = '" + id + "'";
updateCommand.ExecuteNonQuery();
}
catch (Exception excp)
{
logger.Error("Exception SQLAssetPersistor UpdateProperty (for " + typeof(T).Name + "). " +
excp.Message);
throw;
}
}
public static MemberRange <T> CreateRange <T>(MetaDataMember member, int mdrowIndex, MetaDataTable targetTable) where T : MetaDataMember
{
MemberRange <T> range = new MemberRange <T>();
range.Start = Convert.ToInt32(member.MetaDataRow.Parts[mdrowIndex]) - 1;
range.TargetTable = targetTable;
MetaDataTable currentTable = member.NETHeader.TablesHeap.GetTable(member.Table, false);
int memberIndex = (int)(member.metadatatoken | (0xFF << 24)) - (0xFF << 24);
if (currentTable != null)
{
if (memberIndex == currentTable.AmountOfRows)
{
range.Length = targetTable.AmountOfRows - range.Start;
}
else
{
int nextIndex = Convert.ToInt32(currentTable.Members[memberIndex].MetaDataRow.parts[mdrowIndex]) - 1;
range.Length = nextIndex - range.Start;
}
}
if (range.Length > targetTable.AmountOfRows - range.Start)
{
range.Length = 0;
}
return(range);
}
internal DeferredSourceFactory(MetaDataMember member, CommonDataServices services)
{
this.member = member;
this.services = services;
this.refersToPrimaryKey = this.member.IsAssociation && this.member.Association.OtherKeyIsPrimaryKey;
this.empty = new T[] { };
}
private string GetDbType(MetaDataMember mm)
{
var builder = new StringBuilder();
var dbType = mm.DbType;
//bool isUnicode = false;
if (dbType == null)
{
var type = mm.Type;
var t = provider.TypeProvider.From(type);
Debug.Assert(t is DB2DataType);
var fbDbType = (DB2DataType)t;
dbType = fbDbType.ToQueryString();
//isUnicode = fbDbType.IsUnicodeType;
}
builder.Append(dbType);
bool canBeNull = mm.CanBeNull;
if (!canBeNull || mm.IsPrimaryKey)
{
builder.Append(" NOT NULL");
}
return(builder.ToString());
}
private SqlLink BuildLink(SqlExpression item, MetaDataMember member, Expression source)
{
if (member.IsAssociation)
{
SqlExpression[] exprs = new SqlExpression[member.Association.ThisKey.Count];
for (int i = 0, n = exprs.Length; i < n; i++)
{
MetaDataMember mm = member.Association.ThisKey[i];
exprs[i] = sql.Member(item, mm.Member);
}
MetaType otherType = member.Association.OtherType;
return(new SqlLink(new object(), otherType, member.Type, typeProvider.From(member.Type), item, member, exprs, null, source));
}
else
{
// if not association link is always based on primary key
MetaType thisType = member.DeclaringType;
System.Diagnostics.Debug.Assert(thisType.IsEntity);
List <SqlExpression> exprs = new List <SqlExpression>();
foreach (MetaDataMember mm in thisType.IdentityMembers)
{
exprs.Add(sql.Member(item, mm.Member));
}
SqlExpression expansion = sql.Member(item, member.Member);
return(new SqlLink(new object(), thisType, member.Type, typeProvider.From(member.Type), item, member, exprs, expansion, source));
}
}
internal override bool IsMemberPendingGeneration(MetaDataMember keyMember)
{
if (IsNew && keyMember.IsDbGenerated)
{
return(true);
}
foreach (MetaAssociation association in type.Associations)
{
if (!association.IsForeignKey)
{
continue;
}
int index = association.ThisKey.IndexOf(keyMember);
if (index > -1)
{
var boxedValue = association.ThisMember.IsDeferred
? association.ThisMember.DeferredValueAccessor.GetBoxedValue(current)
: association.ThisMember.StorageAccessor.GetBoxedValue(current);
if ((boxedValue != null) && !association.IsMany)
{
var trackedObject = (StandardTrackedObject)tracker.GetTrackedObject(boxedValue);
if (trackedObject == null)
{
continue;
}
var member = association.OtherKey[index];
return(trackedObject.IsMemberPendingGeneration(member));
}
}
}
return(false);
}
internal override bool HasChangedValue(MetaDataMember mm)
{
if (this.current == this.original)
{
return(false);
}
if (mm.IsAssociation && mm.Association.IsMany)
{
return(mm.StorageAccessor.HasAssignedValue(this.original));
}
if (mm.StorageAccessor.HasValue(this.current))
{
if (this.original != null && mm.StorageAccessor.HasValue(this.original))
{
// If the member has ever been in a modified state
// in the past, it is considered modified
if (dirtyMemberCache.Get(mm.Ordinal))
{
return(true);
}
object baseline = mm.MemberAccessor.GetBoxedValue(this.original);
object currentValue = mm.MemberAccessor.GetBoxedValue(this.current);
if (!object.Equals(currentValue, baseline))
{
return(true);
}
return(false);
}
else if (mm.IsDeferred && mm.StorageAccessor.HasAssignedValue(this.current))
{
return(true);
}
}
return(false);
}
public DLinqTableProvider(DLinqDataModelProvider dataModel, MetaType rowType, string name, PropertyInfo prop)
: base(dataModel)
{
_prop = prop;
_rowType = rowType;
Name = name;
DataContextPropertyName = prop.Name;
EntityType = rowType.Type;
ParentEntityType = rowType.InheritanceBase != null ? rowType.InheritanceBase.Type : null;
RootEntityType = rowType.Table.RowType.Type;
_columns = new List <ColumnProvider>();
var members = new List <MetaDataMember>(rowType.DataMembers);
// Add in base-class-first order (not the typical derived-class-first order)
foreach (PropertyInfo propInfo in GetOrderedProperties(rowType.Type))
{
MetaDataMember member = members.FirstOrDefault(m => m.Member.Name == propInfo.Name);
if (member != null)
{
AddColumn(dataModel, member, propInfo);
members.Remove(member);
}
}
// Anything we might've missed, tack it onto the end
foreach (MetaDataMember member in members)
{
AddColumn(dataModel, member, (PropertyInfo)member.Member);
}
_roColumns = new ReadOnlyCollection <ColumnProvider>(_columns);
}
private void btnSave_Click(object sender, EventArgs e)
{
bool errors = false;
var allTextBoxControls = GetControls(this).Where(p => p.Name.StartsWith("tb")).ToList();
MetaTable projectMeta = currentDb.Mapping.GetTable(typeof(Project));
var dataMembers = projectMeta.RowType.PersistentDataMembers.Where(p => !p.CanBeNull && p.Type == typeof(string)).ToList();
foreach (var requiredMember in dataMembers)
{
var requiredValue = currentProject.GetPropertyValue(requiredMember.Name);
if (requiredValue == null || string.IsNullOrWhiteSpace(requiredValue.ToString()))
{
MetaDataMember member = requiredMember;
epUser.SetError(allTextBoxControls.Single(p => p.Name == "tb" + member.Name), "Invalid Input");
errors = true;
}
}
if (errors)
{
return;
}
currentProject.ProjectPreferences = projPreferences;
currentDb.SubmitChanges();
if (newProject)
{
var backupFileName = @"E:\TemporarySpace\" + Guid.NewGuid();
BackupDatabase(backupFileName);
RestoreDatabase(currentProject.DatabaseName, backupFileName);
using (var targetDb = new SkuDataDbDataContext())
{
targetDb.Connection.Open();
targetDb.Connection.ChangeDatabase(currentProject.DatabaseName);
//targetDb.Projects.InsertOnSubmit(currentProject.CloneEntity());
targetDb.Attributes.ForEach(att => att.ProjectID = currentProject.ID);
targetDb.TaxonomyInfos.ForEach(tax => tax.ProjectID = currentProject.ID);
targetDb.Projects.DeleteAllOnSubmit(targetDb.Projects.Where(prj => prj.ID != currentProject.ID));
targetDb.SubmitChanges();
}
}
else
{
using (var targetDb = new SkuDataDbDataContext())
{
targetDb.Connection.Open();
targetDb.Connection.ChangeDatabase(currentProject.DatabaseName);
var targetProject = targetDb.Projects.Single(p => p.ID == currentProject.ID);
targetProject.InjectFrom <ProjectInjection>(currentProject);
targetDb.SubmitChanges();
}
}
MessageBox.Show("Project Created.", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
public bool ValidateReference(MetaDataMember member)
{
if (member.ToString() == _tokenResolver.ResolveMember(member._metadatatoken).ToString())
{
return(false);
}
return(true);
}
// Methods
internal MemberChangeConflict(ObjectChangeConflict conflict, MetaDataMember metaMember)
{
this.conflict = conflict;
this.metaMember = metaMember;
originalValue = metaMember.StorageAccessor.GetBoxedValue(conflict.Original);
databaseValue = metaMember.StorageAccessor.GetBoxedValue(conflict.Database);
currentValue = metaMember.StorageAccessor.GetBoxedValue(conflict.TrackedObject.Current);
}
/// <summary>
/// 从目标对象上获得相关属性的值
/// </summary>
/// <param name="targetResource">定义了相关属性的目标对象
/// </param>
/// <param name="propertyName">需要被更新的属性名
/// </param>
/// <returns>目标对象的属性值
/// </returns>
public object GetValue(object targetResource, string propertyName)
{
MetaTable table = Mapping.GetTable(targetResource.GetType());
MetaDataMember member = table.RowType.DataMembers.Single(
x => x.Name == propertyName);
return(member.MemberAccessor.GetBoxedValue(targetResource));
}
public bool ValidateReference(MetaDataMember member)
{
if (member.ToString() == _tokenResolver.ResolveMember(member._metadatatoken).ToString())
return false;
return true;
}
