|
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Linq;
using System.Runtime.CompilerServices;
namespace System.Data.Linq {
using System.Data.Linq.Mapping;
using System.Data.Linq.Provider;
internal class CommonDataServices : IDataServices {
DataContext context;
MetaModel metaModel;
IdentityManager identifier;
ChangeTracker tracker;
ChangeDirector director;
bool hasCachedObjects;
Dictionary<MetaDataMember, IDeferredSourceFactory> factoryMap;
internal CommonDataServices(DataContext context, MetaModel model) {
this.context = context;
this.metaModel = model;
bool asReadOnly = !context.ObjectTrackingEnabled;
this.identifier = IdentityManager.CreateIdentityManager(asReadOnly);
this.tracker = ChangeTracker.CreateChangeTracker(this, asReadOnly);
this.director = ChangeDirector.CreateChangeDirector(context);
this.factoryMap = new Dictionary<MetaDataMember, IDeferredSourceFactory>();
}
public DataContext Context {
get { return this.context; }
}
public MetaModel Model {
get { return this.metaModel; }
}
internal void SetModel(MetaModel model) {
this.metaModel = model;
}
internal IdentityManager IdentityManager {
get { return this.identifier; }
}
internal ChangeTracker ChangeTracker {
get { return this.tracker; }
}
internal ChangeDirector ChangeDirector {
get { return this.director; }
}
internal IEnumerable<RelatedItem> GetParents(MetaType type, object item) {
return this.GetRelations(type, item, true);
}
internal IEnumerable<RelatedItem> GetChildren(MetaType type, object item) {
return this.GetRelations(type, item, false);
}
private IEnumerable<RelatedItem> GetRelations(MetaType type, object item, bool isForeignKey) {
foreach (MetaDataMember mm in type.PersistentDataMembers) {
if (mm.IsAssociation) {
MetaType otherType = mm.Association.OtherType;
if (mm.Association.IsForeignKey == isForeignKey) {
object value = null;
if (mm.IsDeferred) {
value = mm.DeferredValueAccessor.GetBoxedValue(item);
}
else {
value = mm.StorageAccessor.GetBoxedValue(item);
}
if (value != null) {
if (mm.Association.IsMany) {
IEnumerable list = (IEnumerable)value;
foreach (object otherItem in list) {
yield return new RelatedItem(otherType.GetInheritanceType(otherItem.GetType()), otherItem);
}
}
else {
yield return new RelatedItem(otherType.GetInheritanceType(value.GetType()), value);
}
}
}
}
}
}
internal void ResetServices() {
hasCachedObjects = false;
bool asReadOnly = !context.ObjectTrackingEnabled;
this.identifier = IdentityManager.CreateIdentityManager(asReadOnly);
this.tracker = ChangeTracker.CreateChangeTracker(this, asReadOnly);
this.factoryMap = new Dictionary<MetaDataMember, IDeferredSourceFactory>();
}
internal static object[] GetKeyValues(MetaType type, object instance) {
List<object> keyValues = new List<object>();
foreach (MetaDataMember mm in type.IdentityMembers) {
keyValues.Add(mm.MemberAccessor.GetBoxedValue(instance));
}
return keyValues.ToArray();
}
internal static object[] GetForeignKeyValues(MetaAssociation association, object instance) {
List<object> keyValues = new List<object>();
foreach(MetaDataMember mm in association.ThisKey) {
keyValues.Add(mm.MemberAccessor.GetBoxedValue(instance));
}
return keyValues.ToArray();
}
internal object GetCachedObject(MetaType type, object[] keyValues) {
if( type == null ) {
throw Error.ArgumentNull("type");
}
if (!type.IsEntity) {
return null;
}
return this.identifier.Find(type, keyValues);
}
internal object GetCachedObjectLike(MetaType type, object instance) {
if( type == null ) {
throw Error.ArgumentNull("type");
}
if (!type.IsEntity) {
return null;
}
return this.identifier.FindLike(type, instance);
}
public bool IsCachedObject(MetaType type, object instance) {
if( type == null ) {
throw Error.ArgumentNull("type");
}
if (!type.IsEntity) {
return false;
}
return this.identifier.FindLike(type, instance) == instance;
}
public object InsertLookupCachedObject(MetaType type, object instance) {
if( type == null ) {
throw Error.ArgumentNull("type");
}
hasCachedObjects = true; // flag that we have cached objects
if (!type.IsEntity) {
return instance;
}
return this.identifier.InsertLookup(type, instance);
}
public bool RemoveCachedObjectLike(MetaType type, object instance) {
if (type == null) {
throw Error.ArgumentNull("type");
}
if (!type.IsEntity) {
return false;
}
return this.identifier.RemoveLike(type, instance);
}
public void OnEntityMaterialized(MetaType type, object instance) {
if (type == null) {
throw Error.ArgumentNull("type");
}
this.tracker.FastTrack(instance);
if (type.HasAnyLoadMethod) {
SendOnLoaded(type, instance);
}
}
private static void SendOnLoaded(MetaType type, object item) {
if (type != null) {
SendOnLoaded(type.InheritanceBase, item);
if (type.OnLoadedMethod != null) {
try {
type.OnLoadedMethod.Invoke(item, new object[] { });
} catch (TargetInvocationException tie) {
if (tie.InnerException != null) {
throw tie.InnerException;
}
throw;
}
}
}
}
/// <summary>
/// Returns a query for the entity indicated by the specified key.
/// </summary>
internal Expression GetObjectQuery(MetaType type, object[] keyValues) {
if (type == null) {
throw Error.ArgumentNull("type");
}
if (keyValues == null) {
throw Error.ArgumentNull("keyValues");
}
return this.GetObjectQuery(type, BuildKeyExpressions(keyValues, type.IdentityMembers));
}
internal Expression GetObjectQuery(MetaType type, Expression[] keyValues) {
ITable table = this.context.GetTable(type.InheritanceRoot.Type);
ParameterExpression serverItem = Expression.Parameter(table.ElementType, "p");
// create a where expression including all the identity members
Expression whereExpression = null;
for (int i = 0, n = type.IdentityMembers.Count; i < n; i++) {
MetaDataMember metaMember = type.IdentityMembers[i];
Expression memberExpression = (metaMember.Member is FieldInfo)
? Expression.Field(serverItem, (FieldInfo)metaMember.Member)
: Expression.Property(serverItem, (PropertyInfo)metaMember.Member);
Expression memberEqualityExpression = Expression.Equal(memberExpression, keyValues[i]);
whereExpression = (whereExpression != null)
? Expression.And(whereExpression, memberEqualityExpression)
: memberEqualityExpression;
}
return Expression.Call(typeof(Queryable), "Where", new Type[] { table.ElementType }, table.Expression, Expression.Lambda(whereExpression, serverItem));
}
internal Expression GetDataMemberQuery(MetaDataMember member, Expression[] keyValues) {
if (member == null)
throw Error.ArgumentNull("member");
if (keyValues == null)
throw Error.ArgumentNull("keyValues");
if (member.IsAssociation) {
MetaAssociation association = member.Association;
Type rootType = association.ThisMember.DeclaringType.InheritanceRoot.Type;
Expression thisSource = Expression.Constant(context.GetTable(rootType));
if (rootType != association.ThisMember.DeclaringType.Type) {
thisSource = Expression.Call(typeof(Enumerable), "Cast", new Type[] { association.ThisMember.DeclaringType.Type }, thisSource);
}
Expression thisInstance = Expression.Call(typeof(Enumerable), "FirstOrDefault", new Type[] { association.ThisMember.DeclaringType.Type },
System.Data.Linq.SqlClient.Translator.WhereClauseFromSourceAndKeys(thisSource, association.ThisKey.ToArray(), keyValues)
);
Expression otherSource = Expression.Constant(context.GetTable(association.OtherType.InheritanceRoot.Type));
if (association.OtherType.Type!=association.OtherType.InheritanceRoot.Type) {
otherSource = Expression.Call(typeof(Enumerable), "Cast", new Type[] { association.OtherType.Type }, otherSource);
}
Expression expr = System.Data.Linq.SqlClient.Translator.TranslateAssociation(
this.context, association, otherSource, keyValues, thisInstance
);
return expr;
}
else {
Expression query = this.GetObjectQuery(member.DeclaringType, keyValues);
Type elementType = System.Data.Linq.SqlClient.TypeSystem.GetElementType(query.Type);
ParameterExpression p = Expression.Parameter(elementType, "p");
Expression e = p;
if (elementType != member.DeclaringType.Type)
e = Expression.Convert(e, member.DeclaringType.Type);
Expression mem = (member.Member is PropertyInfo)
? Expression.Property(e, (PropertyInfo)member.Member)
: Expression.Field(e, (FieldInfo)member.Member);
LambdaExpression selector = Expression.Lambda(mem, p);
return Expression.Call(typeof(Queryable), "Select", new Type[] { elementType, selector.Body.Type }, query, selector);
}
}
private static Expression[] BuildKeyExpressions(object[] keyValues, ReadOnlyCollection<MetaDataMember> keyMembers) {
Expression[] keyValueExpressions = new Expression[keyValues.Length];
for (int i = 0, n = keyMembers.Count; i < n; i++) {
MetaDataMember metaMember = keyMembers[i];
Expression keyValueExpression = Expression.Constant(keyValues[i], metaMember.Type);
keyValueExpressions[i] = keyValueExpression;
}
return keyValueExpressions;
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public IDeferredSourceFactory GetDeferredSourceFactory(MetaDataMember member) {
if (member == null) {
throw Error.ArgumentNull("member");
}
IDeferredSourceFactory factory;
if (this.factoryMap.TryGetValue(member, out factory)) {
return factory;
}
Type elemType = member.IsAssociation && member.Association.IsMany
? System.Data.Linq.SqlClient.TypeSystem.GetElementType(member.Type)
: member.Type;
factory = (IDeferredSourceFactory) Activator.CreateInstance(
typeof(DeferredSourceFactory<>).MakeGenericType(elemType),
BindingFlags.Instance | BindingFlags.NonPublic, null,
new object[] { member, this }, null
);
this.factoryMap.Add(member, factory);
return factory;
}
class DeferredSourceFactory<T> : IDeferredSourceFactory {
MetaDataMember member;
CommonDataServices services;
ICompiledQuery query;
bool refersToPrimaryKey;
T[] empty;
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[] { };
}
public IEnumerable CreateDeferredSource(object instance) {
if (instance == null)
throw Error.ArgumentNull("instance");
return new DeferredSource(this, instance);
}
public IEnumerable CreateDeferredSource(object[] keyValues) {
if (keyValues == null)
throw Error.ArgumentNull("keyValues");
return new DeferredSource(this, keyValues);
}
private IEnumerator<T> Execute(object instance) {
ReadOnlyCollection<MetaDataMember> keys = null;
if (this.member.IsAssociation) {
keys = this.member.Association.ThisKey;
}
else {
keys = this.member.DeclaringType.IdentityMembers;
}
object[] keyValues = new object[keys.Count];
for (int i = 0, n = keys.Count; i < n; i++) {
object value = keys[i].StorageAccessor.GetBoxedValue(instance);
keyValues[i] = value;
}
if (this.HasNullForeignKey(keyValues)) {
return ((IEnumerable<T>)this.empty).GetEnumerator();
}
T cached;
if (this.TryGetCachedObject(keyValues, out cached)) {
return ((IEnumerable<T>)(new T[] { cached })).GetEnumerator();
}
if (this.member.LoadMethod != null) {
try {
object result = this.member.LoadMethod.Invoke(this.services.Context, new object[] { instance });
if (typeof(T).IsAssignableFrom(this.member.LoadMethod.ReturnType)) {
return ((IEnumerable<T>)new T[] { (T)result }).GetEnumerator();
}
else {
return ((IEnumerable<T>)result).GetEnumerator();
}
}
catch (TargetInvocationException tie) {
if (tie.InnerException != null) {
throw tie.InnerException;
}
throw;
}
}
else {
return this.ExecuteKeyQuery(keyValues);
}
}
private IEnumerator<T> ExecuteKeys(object[] keyValues) {
if (this.HasNullForeignKey(keyValues)) {
return ((IEnumerable<T>)this.empty).GetEnumerator();
}
T cached;
if (this.TryGetCachedObject(keyValues, out cached)) {
return ((IEnumerable<T>)(new T[] { cached })).GetEnumerator();
}
return this.ExecuteKeyQuery(keyValues);
}
private bool HasNullForeignKey(object[] keyValues) {
if (this.refersToPrimaryKey) {
bool keyHasNull = false;
for (int i = 0, n = keyValues.Length; i < n; i++) {
keyHasNull |= keyValues[i] == null;
}
if (keyHasNull) {
return true;
}
}
return false;
}
private bool TryGetCachedObject(object[] keyValues, out T cached) {
cached = default(T);
if (this.refersToPrimaryKey) {
// look to see if we already have this object in the identity cache
MetaType mt = this.member.IsAssociation ? this.member.Association.OtherType : this.member.DeclaringType;
object obj = this.services.GetCachedObject(mt, keyValues);
if (obj != null) {
cached = (T)obj;
return true;
}
}
return false;
}
private IEnumerator<T> ExecuteKeyQuery(object[] keyValues) {
if (this.query == null) {
ParameterExpression p = Expression.Parameter(typeof(object[]), "keys");
Expression[] keyExprs = new Expression[keyValues.Length];
ReadOnlyCollection<MetaDataMember> members = this.member.IsAssociation ? this.member.Association.OtherKey : this.member.DeclaringType.IdentityMembers;
for (int i = 0, n = keyValues.Length; i < n; i++) {
MetaDataMember mm = members[i];
keyExprs[i] = Expression.Convert(
#pragma warning disable 618 // Disable the 'obsolete' warning
Expression.ArrayIndex(p, Expression.Constant(i)),
#pragma warning restore 618
mm.Type
);
}
Expression q = this.services.GetDataMemberQuery(this.member, keyExprs);
LambdaExpression lambda = Expression.Lambda(q, p);
this.query = this.services.Context.Provider.Compile(lambda);
}
return ((IEnumerable<T>)this.query.Execute(this.services.Context.Provider, new object[] { keyValues }).ReturnValue).GetEnumerator();
}
class DeferredSource : IEnumerable<T>, IEnumerable {
DeferredSourceFactory<T> factory;
object instance;
internal DeferredSource(DeferredSourceFactory<T> factory, object instance) {
this.factory = factory;
this.instance = instance;
}
public IEnumerator<T> GetEnumerator() {
object[] keyValues = this.instance as object[];
if (keyValues != null) {
return this.factory.ExecuteKeys(keyValues);
}
return this.factory.Execute(this.instance);
}
IEnumerator IEnumerable.GetEnumerator() {
return this.GetEnumerator();
}
}
}
/// <summary>
/// Returns true if any objects have been added to the identity cache. If
/// object tracking is disabled, this still returns true if any attempts
/// where made to cache an object. Thus regardless of object tracking mode,
/// this can be used as an indicator as to whether any result returning queries
/// have been executed.
/// </summary>
internal bool HasCachedObjects {
get {
return this.hasCachedObjects;
}
}
public object GetCachedObject(Expression query) {
if (query == null)
return null;
MethodCallExpression mc = query as MethodCallExpression;
if (mc == null || mc.Arguments.Count < 1 || mc.Arguments.Count > 2)
return null;
if (mc.Method.DeclaringType != typeof(Queryable)) {
return null;
}
switch (mc.Method.Name) {
case "Where":
case "First":
case "FirstOrDefault":
case "Single":
case "SingleOrDefault":
break;
default:
return null;
}
if (mc.Arguments.Count == 1) {
// If it is something like
// context.Customers.Where(c => c.ID = 123).First()
// then it is equivalent of
// context.Customers.First(c => c.ID = 123)
// hence reduce to context.Customers.Where(c => c.ID = 123) and process the remaining query
return GetCachedObject(mc.Arguments[0]);
}
UnaryExpression quote = mc.Arguments[1] as UnaryExpression;
if (quote == null || quote.NodeType != ExpressionType.Quote)
return null;
LambdaExpression pred = quote.Operand as LambdaExpression;
if (pred == null)
return null;
ConstantExpression cex = mc.Arguments[0] as ConstantExpression;
if (cex == null)
return null;
ITable t = cex.Value as ITable;
if (t == null)
return null;
Type elementType = System.Data.Linq.SqlClient.TypeSystem.GetElementType(query.Type);
if (elementType != t.ElementType)
return null;
MetaTable metaTable = this.metaModel.GetTable(t.ElementType);
object[] keyValues = this.GetKeyValues(metaTable.RowType, pred);
if (keyValues != null) {
return this.GetCachedObject(metaTable.RowType, keyValues);
}
return null;
}
internal object[] GetKeyValues(MetaType type, LambdaExpression predicate) {
if (predicate == null)
throw Error.ArgumentNull("predicate");
if (predicate.Parameters.Count != 1)
return null;
Dictionary<MetaDataMember, object> keys = new Dictionary<MetaDataMember, object>();
if (this.GetKeysFromPredicate(type, keys, predicate.Body)
&& keys.Count == type.IdentityMembers.Count) {
object[] values = keys.OrderBy(kv => kv.Key.Ordinal).Select(kv => kv.Value).ToArray();
return values;
}
return null;
}
private bool GetKeysFromPredicate(MetaType type, Dictionary<MetaDataMember, object> keys, Expression expr) {
BinaryExpression bex = expr as BinaryExpression;
if (bex == null) {
MethodCallExpression mex = expr as MethodCallExpression;
if (mex != null && mex.Method.Name == "op_Equality" && mex.Arguments.Count == 2) {
bex = Expression.Equal(mex.Arguments[0], mex.Arguments[1]);
}
else {
return false;
}
}
switch (bex.NodeType) {
case ExpressionType.And:
return this.GetKeysFromPredicate(type, keys, bex.Left) &&
this.GetKeysFromPredicate(type, keys, bex.Right);
case ExpressionType.Equal:
return GetKeyFromPredicate(type, keys, bex.Left, bex.Right) ||
GetKeyFromPredicate(type, keys, bex.Right, bex.Left);
default:
return false;
}
}
private static bool GetKeyFromPredicate(MetaType type, Dictionary<MetaDataMember, object> keys, Expression mex, Expression vex) {
MemberExpression memex = mex as MemberExpression;
if (memex == null || memex.Expression == null ||
memex.Expression.NodeType != ExpressionType.Parameter || memex.Expression.Type != type.Type) {
return false;
}
if (!type.Type.IsAssignableFrom(memex.Member.ReflectedType) && !memex.Member.ReflectedType.IsAssignableFrom(type.Type)) {
return false;
}
MetaDataMember mm = type.GetDataMember(memex.Member);
if (!mm.IsPrimaryKey) {
return false;
}
if (keys.ContainsKey(mm)) {
return false;
}
ConstantExpression cex = vex as ConstantExpression;
if (cex != null) {
keys.Add(mm, cex.Value);
return true;
}
InvocationExpression ie = vex as InvocationExpression;
if (ie != null && ie.Arguments != null && ie.Arguments.Count == 0) {
ConstantExpression ce = ie.Expression as ConstantExpression;
if (ce != null) {
keys.Add(mm, ((Delegate)ce.Value).DynamicInvoke(new object[] {}));
return true;
}
}
return false;
}
/// <summary>
/// Either returns the object from cache if it is in cache, or
/// queries for it.
/// </summary>
internal object GetObjectByKey(MetaType type, object[] keyValues) {
// first check the cache
object target = GetCachedObject(type, keyValues);
if (target == null) {
// no cached value, so query for it
target = ((IEnumerable)this.context.Provider.Execute(this.GetObjectQuery(type, keyValues)).ReturnValue).OfType<object>().SingleOrDefault();
}
return target;
}
}
internal struct RelatedItem {
internal MetaType Type;
internal object Item;
internal RelatedItem(MetaType type, object item) {
this.Type = type;
this.Item = item;
}
}
}
|