|
//---------------------------------------------------------------------
// <copyright file="ObjectStateManagerMetadata.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Data.Metadata.Edm;
using System.Data.Mapping;
using System.Diagnostics;
namespace System.Data.Objects
{
internal struct EntitySetQualifiedType : IEqualityComparer<EntitySetQualifiedType>
{
internal static readonly IEqualityComparer<EntitySetQualifiedType> EqualityComparer = new EntitySetQualifiedType();
internal readonly Type ClrType;
internal readonly EntitySet EntitySet;
internal EntitySetQualifiedType(Type type, EntitySet set)
{
Debug.Assert(null != type, "null Type");
Debug.Assert(null != set, "null EntitySet");
Debug.Assert(null != set.EntityContainer, "null EntityContainer");
Debug.Assert(null != set.EntityContainer.Name, "null EntityContainer.Name");
ClrType = EntityUtil.GetEntityIdentityType(type);
EntitySet = set;
}
public bool Equals(EntitySetQualifiedType x, EntitySetQualifiedType y)
{
return (Object.ReferenceEquals(x.ClrType, y.ClrType) &&
Object.ReferenceEquals(x.EntitySet, y.EntitySet));
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2303", Justification="ClrType is not expected to be an Embedded Interop Type.")]
public int GetHashCode(EntitySetQualifiedType obj)
{
return unchecked(obj.ClrType.GetHashCode() +
obj.EntitySet.Name.GetHashCode() +
obj.EntitySet.EntityContainer.Name.GetHashCode());
}
}
internal sealed class StateManagerMemberMetadata
{
private readonly EdmProperty _clrProperty; // may be null if shadowState
private readonly EdmProperty _edmProperty;
private readonly bool _isPartOfKey;
private readonly bool _isComplexType;
internal StateManagerMemberMetadata(ObjectPropertyMapping memberMap, EdmProperty memberMetadata, bool isPartOfKey)
{
// if memberMap is null, then this is a shadowstate
Debug.Assert(null != memberMap, "shadowstate not supported");
Debug.Assert(null != memberMetadata, "CSpace should never be null");
_clrProperty = memberMap.ClrProperty;
_edmProperty = memberMetadata;
_isPartOfKey = isPartOfKey;
_isComplexType = (Helper.IsEntityType(_edmProperty.TypeUsage.EdmType) ||
Helper.IsComplexType(_edmProperty.TypeUsage.EdmType));
}
internal string CLayerName
{
get
{
return _edmProperty.Name;
}
}
internal Type ClrType
{
get
{
Debug.Assert(null != _clrProperty, "shadowstate not supported");
return _clrProperty.TypeUsage.EdmType.ClrType;
//return ((null != _clrProperty)
// ? _clrProperty.TypeUsage.EdmType.ClrType
// : (Helper.IsComplexType(_edmProperty)
// ? typeof(DbDataRecord)
// : ((PrimitiveType)_edmProperty.TypeUsage.EdmType).ClrEquivalentType));
}
}
internal bool IsComplex
{
get
{
return _isComplexType;
}
}
internal EdmProperty CdmMetadata
{
get
{
return _edmProperty;
}
}
internal EdmProperty ClrMetadata
{
get
{
Debug.Assert(null != _clrProperty, "shadowstate not supported");
return _clrProperty;
}
}
internal bool IsPartOfKey
{
get
{
return _isPartOfKey;
}
}
public object GetValue(object userObject) // wrapp it in cacheentry
{
Debug.Assert(null != _clrProperty, "shadowstate not supported");
object dataObject = LightweightCodeGenerator.GetValue(_clrProperty, userObject);
return dataObject;
}
public void SetValue(object userObject, object value) // if record , unwrapp to object, use materializer in cacheentry
{
Debug.Assert(null != _clrProperty, "shadowstate not supported");
if (DBNull.Value == value)
{
value = null;
}
if (IsComplex && value == null)
{
throw EntityUtil.NullableComplexTypesNotSupported(CLayerName);
}
LightweightCodeGenerator.SetValue(_clrProperty, userObject, value);
}
}
internal sealed class StateManagerTypeMetadata
{
private readonly TypeUsage _typeUsage; // CSpace
private readonly ObjectTypeMapping _ocObjectMap;
private readonly StateManagerMemberMetadata[] _members;
private readonly Dictionary<string, int> _objectNameToOrdinal;
private readonly Dictionary<string, int> _cLayerNameToOrdinal;
private readonly DataRecordInfo _recordInfo;
internal StateManagerTypeMetadata(EdmType edmType, ObjectTypeMapping mapping)
{
Debug.Assert(null != edmType, "null EdmType");
Debug.Assert(Helper.IsEntityType(edmType) ||
Helper.IsComplexType(edmType),
"not Complex or EntityType");
Debug.Assert(Object.ReferenceEquals(mapping, null) ||
Object.ReferenceEquals(mapping.EdmType, edmType),
"different EdmType instance");
_typeUsage = TypeUsage.Create(edmType);
_recordInfo = new DataRecordInfo(_typeUsage);
_ocObjectMap = mapping;
ReadOnlyMetadataCollection<EdmProperty> members = TypeHelpers.GetProperties(edmType);
_members = new StateManagerMemberMetadata[members.Count];
_objectNameToOrdinal = new Dictionary<string, int>(members.Count);
_cLayerNameToOrdinal = new Dictionary<string, int>(members.Count);
ReadOnlyMetadataCollection<EdmMember> keyMembers = null;
if (Helper.IsEntityType(edmType))
{
keyMembers = ((EntityType)edmType).KeyMembers;
}
for (int i = 0; i < _members.Length; ++i)
{
EdmProperty member = members[i];
ObjectPropertyMapping memberMap = null;
if (null != mapping)
{
memberMap = mapping.GetPropertyMap(member.Name);
if (null != memberMap)
{
_objectNameToOrdinal.Add(memberMap.ClrProperty.Name, i); // olayer name
}
}
_cLayerNameToOrdinal.Add(member.Name, i); // clayer name
// Determine whether this member is part of the identity of the entity.
_members[i] = new StateManagerMemberMetadata(memberMap, member, ((null != keyMembers) && keyMembers.Contains(member)));
}
}
internal TypeUsage CdmMetadata
{
get
{
return _typeUsage;
}
}
internal DataRecordInfo DataRecordInfo
{
get { return _recordInfo; }
}
internal int FieldCount
{
get
{
return _members.Length;
}
}
internal Type GetFieldType(int ordinal)
{
return Member(ordinal).ClrType;
}
internal StateManagerMemberMetadata Member(int ordinal)
{
if (unchecked((uint)ordinal < (uint)_members.Length))
{
return _members[ordinal];
}
throw EntityUtil.ArgumentOutOfRange("ordinal");
}
internal IEnumerable<StateManagerMemberMetadata> Members
{
get { return _members; }
}
internal string CLayerMemberName(int ordinal)
{
return Member(ordinal).CLayerName;
}
internal int GetOrdinalforOLayerMemberName(string name)
{
int ordinal;
if (String.IsNullOrEmpty(name) || !_objectNameToOrdinal.TryGetValue(name, out ordinal))
{
ordinal = -1;
}
return ordinal;
}
internal int GetOrdinalforCLayerMemberName(string name)
{
int ordinal;
if (String.IsNullOrEmpty(name) || !_cLayerNameToOrdinal.TryGetValue(name, out ordinal))
{
ordinal = -1;
}
return ordinal;
}
internal bool IsMemberPartofShadowState(int ordinal)
{
//
Debug.Assert(Member(ordinal) != null,
"The only case where Member(ordinal) can be null is if the property is in shadow state. " +
"When shadow state support is added, this assert should never fire.");
return (null == Member(ordinal).ClrMetadata);
}
}
}
|