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; }