Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

612 lines
26 KiB
C#

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