/// <summary>
/// Gets the resource.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="fullTypeName">Full name of the type.</param>
/// <returns></returns>
object IUpdatable.GetResource(System.Linq.IQueryable query, string fullTypeName)
{
// Get the first result
IEnumerable results = (IEnumerable)query;
object returnValue = null;
foreach (object result in results)
{
if (returnValue != null)
{
break;
}
returnValue = result;
}
// Check the Typename if needed
if (fullTypeName != null)
{
if (fullTypeName != returnValue.GetType().FullName)
{
throw new DataServiceException("Incorrect Type Returned");
}
}
// Return the resource
return(returnValue);
}
/// <summary>
/// Gets the user dddress id based on the user full name.
/// </summary>
/// <param name="userName">The user full name to search on.</param>
/// <returns>The user id.</returns>
public virtual Int64 GetUserIDForUserName(string userName)
{
Int64 ret = 0;
// Split the user name.
char[] delimeter = new char[] { ' ' };
string[] splitList = userName.Split(delimeter);
// Get the name of the user
// from the split data.
string firstName = splitList[0].Trim();
string lastName = splitList[1].Trim();
// Get the current user name.
System.Linq.IQueryable query =
Select.
SelectIQueryableItems(u => (u.FirstName == firstName) && (u.LastName == lastName)).
Select(u => new { UserIdentity = u.UserAddressID });
// Get the property.
PropertyInfo property = query.ElementType.GetProperty("UserIdentity");
// Find the first user id.
foreach (var item in query)
{
ret = (Int64)property.GetValue(item, null);
break;
}
// Return the user id.
return(ret);
}
private void AssertSupportedAndResultNotNullable(
IQueryable query,
string expectedEntityName,
string expectedMemberPath,
Predicate <IType> expectedMemberType,
Predicate <IAbstractComponentType> expectedComponentType = null)
{
AssertResult(query, true, true, expectedEntityName, expectedMemberPath, expectedMemberType, expectedComponentType, false);
}
private void AssertResult(
IQueryable query,
bool rewriteQuery,
bool supported,
string expectedEntityName,
string expectedMemberPath,
Predicate <IType> expectedMemberType,
Predicate <IAbstractComponentType> expectedComponentType = null,
bool nullability = true)
{
expectedComponentType = expectedComponentType ?? (o => o == null);
var expression = query.Expression;
var preTransformResult = NhRelinqQueryParser.PreTransform(expression, new PreTransformationParameters(QueryMode.Select, Sfi));
expression = preTransformResult.Expression;
var constantToParameterMap = ExpressionParameterVisitor.Visit(preTransformResult);
var queryModel = NhRelinqQueryParser.Parse(expression);
var requiredHqlParameters = new List <NamedParameterDescriptor>();
var visitorParameters = new VisitorParameters(
Sfi,
constantToParameterMap,
requiredHqlParameters,
new QuerySourceNamer(),
expression.Type,
QueryMode.Select);
if (rewriteQuery)
{
QueryModelVisitor.GenerateHqlQuery(
queryModel,
visitorParameters,
true,
NhLinqExpressionReturnType.Scalar);
}
var found = _tryGetMappedType(
Sfi,
queryModel.SelectClause.Selector,
out var memberType,
out var entityPersister,
out var componentType,
out var memberPath);
Assert.That(found, Is.EqualTo(supported), $"Expression should be {(supported ? "supported" : "unsupported")}");
Assert.That(entityPersister?.EntityName, Is.EqualTo(expectedEntityName), "Invalid entity name");
Assert.That(memberPath, Is.EqualTo(expectedMemberPath), "Invalid member path");
Assert.That(() => expectedMemberType(memberType), $"Invalid member type: {memberType?.Name ?? "null"}");
Assert.That(() => expectedComponentType(componentType), $"Invalid component type: {componentType?.Name ?? "null"}");
if (found)
{
Assert.That(_tryGetMappedNullability(Sfi, queryModel.SelectClause.Selector, out var isNullable), Is.True, "Expression should be supported");
Assert.That(nullability, Is.EqualTo(isNullable), "Nullability is not correct");
}
}
/// <summary>
/// 删除对象
/// </summary>
/// <param name="items"></param>
public void Delete(System.Linq.IQueryable items)
{
Type dataType = items.GetType().GetGenericArguments()[0];
var tableSchema = SchemaManager.GetSchemaTable(dataType);
if (tableSchema.KeyColumn == null)
{
throw new Exception(dataType.Name + "没有定义主键");
}
bool needCloseConnection = false;
if (this.Database.Connection.State != System.Data.ConnectionState.Open)
{
needCloseConnection = true;
this.Database.Connection.Open();
}
int pagesize = 100;
try
{
var query = InvokeSelect(items, tableSchema.KeyColumn.PropertyName);
while (true)
{
var data1 = InvokeTake(query, pagesize);
var dataitems = (System.Array)InvokeToArray(data1);
foreach (var idvalue in dataitems)
{
var deldataItem = (DataItem)Activator.CreateInstance(dataType);
deldataItem.SetValue(tableSchema.KeyColumn.PropertyName, idvalue);
deldataItem.ChangedProperties.Clear();
Delete(deldataItem);
}
if (dataitems.Length < pagesize)
{
break;
}
}
}
catch (Exception)
{
throw;
}
finally
{
if (needCloseConnection)
{
this.Database.Connection.Close();
}
}
}
private void AssertSupported(
IQueryable query,
bool rewriteQuery,
string expectedEntityName,
string expectedMemberPath,
Predicate <IType> expectedMemberType,
Predicate <IAbstractComponentType> expectedComponentType = null)
{
AssertResult(query, rewriteQuery, true, expectedEntityName, expectedMemberPath, expectedMemberType, expectedComponentType);
}
private void AssertSupported(
IQueryable query,
string expectedEntityName,
string expectedMemberPath,
Predicate <IType> expectedMemberType,
Predicate <IAbstractComponentType> expectedComponentType = null,
bool?nullability = true)
{
AssertResult(query, true, true, expectedEntityName, expectedMemberPath, expectedMemberType, expectedComponentType, nullability);
}
public String ToSql(System.Linq.IQueryable queryable)
{
var sessionProperty = typeof(DefaultQueryProvider).GetProperty("Session", BindingFlags.NonPublic | BindingFlags.Instance);
var session = sessionProperty.GetValue(queryable.Provider, null) as ISession;
var sessionImpl = session.GetSessionImplementation();
var factory = sessionImpl.Factory;
var nhLinqExpression = new NhLinqExpression(queryable.Expression, factory);
var translatorFactory = new ASTQueryTranslatorFactory();
var translator = translatorFactory.CreateQueryTranslators(nhLinqExpression, null, false, sessionImpl.EnabledFilters, factory).First();
//in case you want the parameters as well
//var parameters = nhLinqExpression.ParameterValuesByName.ToDictionary(x => x.Key, x => x.Value.Item1);
return(translator.SQLString);
}
public IActionResult Index(Project.Category category)
{
var enumValues = Enum.GetValues(typeof(Project.Category));
System.Linq.IQueryable result = null;
if (category == 0)
{
result = _context.Project.Include(p => p.ProjectCtratorNavigation)
.Include(p => p.ProjectCtratorNavigation.UserDetailsNavigation).OrderBy(p => p.ProjectCtrator);
}
else
{
result = _context.Project.Include(p => p.ProjectCtratorNavigation).
Include(p => p.ProjectCtratorNavigation.UserDetailsNavigation).
Where(p => p.ProjectCategory == category).OrderBy(p => p.ProjectCtrator);
}
ViewData["ddProjectCategory"] = category;
return(View(result));
}
/// <summary>
/// 开启更新锁
/// </summary>
/// <param name="items"></param>
public void UpdateLock(System.Linq.IQueryable items)
{
if (this.Database.Connection.State != System.Data.ConnectionState.Open)
{
throw new Exception("没有开启事务");
}
Type dataType = items.GetType().GetGenericArguments()[0];
var tableSchema = SchemaManager.GetSchemaTable(dataType);
if (tableSchema.KeyColumn == null)
{
throw new Exception(dataType.Name + "没有定义主键");
}
int pagesize = 100;
var query = InvokeSelect(items, tableSchema.KeyColumn.PropertyName);
int skip = 0;
while (true)
{
var skipQuery = InvokeSkip(query, skip);
var data1 = InvokeTake(skipQuery, pagesize);
var dataitems = (System.Array)InvokeToArray(data1);
foreach (var idvalue in dataitems)
{
this.Database.UpdateLock(dataType, idvalue);
}
if (dataitems.Length < pagesize)
{
break;
}
skip += pagesize;
}
}
/// <summary>
/// 将LINQ的查询结果转换为DataTable最简单的实现方法
/// </summary>
/// <param name="queryable">要转换的结果集</param>
/// <returns>转换后的表</returns>
public static DataTable ConvertToDataTable(System.Linq.IQueryable queryable)
{
DataTable dt = new DataTable();
var props = queryable.ElementType.GetProperties();
foreach (PropertyInfo pi in props)
{
Type colType = pi.PropertyType;
if ((colType.IsGenericType) && (colType.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
colType = colType.GetGenericArguments()[0];
}
dt.Columns.Add(new DataColumn(pi.Name, colType));
}
foreach (var item in queryable)
{
DataRow dr = dt.NewRow();
foreach (System.Reflection.PropertyInfo pi in props)
{
if (pi.GetValue(item, null) != null)
{
if (pi.GetValue(item, null) != null)
{
dr[pi.Name] = pi.GetValue(item, null);
}
}
}
dt.Rows.Add(dr);
}
return(dt);
}
/// <summary>
/// Gets the user full name based on the user id.
/// </summary>
/// <param name="userAddressID">The user address id to search on.</param>
/// <returns>The user full name.</returns>
public virtual string GetUserNameForUserID(Int64 userAddressID)
{
string ret = null;
// Get the current user id.
System.Linq.IQueryable query =
Select.
SelectIQueryableItems(u => u.UserAddressID == userAddressID).
Select(u => new { UserName = (u.FirstName + " " + u.LastName) });
// Get the property.
PropertyInfo property = query.ElementType.GetProperty("UserName");
// Find the first user name.
foreach (var item in query)
{
ret = (string)property.GetValue(item, null);
break;
}
// Return the user full name.
return(ret);
}
/// <summary>
/// Gets the resource of the specified type identified by a query and type name.
/// </summary>
/// <param name="query">Language integrated query (LINQ) pointing to a particular resource.</param>
/// <param name="fullTypeName">The fully qualified type name of resource.</param>
/// <returns>
/// An opaque object representing a resource of the specified type, referenced by the specified query.
/// </returns>
public virtual object GetResource(System.Linq.IQueryable query, string fullTypeName)
{
if (query == null)
{
throw new ArgumentException("The specified IQueryable is null.");
}
object resource = null;
foreach (object r in query)
{
if (resource != null)
{
throw new ArgumentException(String.Format(System.Globalization.CultureInfo.CurrentCulture, "Invalid Uri specified. The query '{0}' must refer to a single resource", query.ToString()));
}
resource = r;
}
if (resource != null)
{
Type resourceType = resource.GetType();
if (fullTypeName != null)
{
if (resourceType.FullName != fullTypeName)
{
throw new ArgumentException("Unknown resource type '" + fullTypeName + "'.");
}
}
this.session.GetTable(resourceType, this.GetTableId(resourceType)).SetSubmitAction(resource, SubmitAction.PossibleUpdate);
return(resource);
}
return(null);
}
/// <summary>
/// Gets the resource of the given type that the query points to
/// </summary>
/// <param name="query">query pointing to a particular resource</param>
/// <param name="fullTypeName">full type name i.e. Namespace qualified type name of the resource</param>
/// <returns>object representing a resource of given type and as referenced by the query</returns>
/// <remarks>This method should obtain a single result from the specified <paramref name="query"/>. It should fail if no or more than one result
/// can be obtain by evaluating such query.
/// The result should then be converted to its resource "handle" and that handle should be returned from the method.
/// The <paramref name="fullTypeName"/> is the expected FullName of the resource type of the resource to be retrieved. If this parameter is null
/// the method should ignore it. If it's not null, the method should check that the resource returned by the query is of this resource type
/// and fail if that's not the case.</remarks>
public object GetResource(System.Linq.IQueryable query, string fullTypeName)
{
// Since we're not using resource handles we're going to return the resource itself.
object resource = null;
foreach (object r in query)
{
if (resource != null)
{
throw new ArgumentException(String.Format("Invalid Uri specified. The query '{0}' must refer to a single resource", query.ToString()));
}
resource = r;
}
if (resource != null)
{
if (fullTypeName != null)
{
ResourceType resourceType;
if (!this.metadata.TryResolveResourceType(fullTypeName, out resourceType))
{
throw new ArgumentException("Unknown resource type '" + fullTypeName + "'.");
}
if (resource.GetType() != resourceType.InstanceType)
{
throw new System.ArgumentException(String.Format("Invalid uri specified. ExpectedType: '{0}', ActualType: '{1}'", fullTypeName, resource.GetType().FullName));
}
}
return(resource);
}
return(null);
}
protected override System.Linq.IQueryable SortDistinctValues(System.Linq.IQueryable source)
{
return(base.SortDistinctValuesByFilteringDisplay(source));
}
/// <summary>
/// 删除对象
/// </summary>
/// <param name="items"></param>
public void Delete(System.Linq.IQueryable items)
{
Type dataType = items.GetType().GetGenericArguments()[0];
string pkid = null;
if (dataType != null)
{
try
{
var att = dataType.GetTypeInfo().GetCustomAttribute(typeof(Attributes.Table)) as Attributes.Table;
if (att != null)
{
pkid = att.KeyName;
}
}
catch
{
}
}
if (pkid == null)
{
throw new Exception(dataType.Name + "没有定义主键");
}
bool needCloseConnection = false;
if (this.Database.Connection.State != System.Data.ConnectionState.Open)
{
needCloseConnection = true;
this.Database.Connection.Open();
}
try
{
var query = InvokeSelect(items, pkid);
while (true)
{
var data1 = InvokeTake(query, 100);
var dataitems = (System.Collections.IList)InvokeToList(data1);
if (dataitems.Count == 0)
{
break;
}
foreach (var idvalue in dataitems)
{
var deldataItem = (DataItem)Activator.CreateInstance(dataType);
deldataItem.SetValue(pkid, idvalue);
Delete(deldataItem);
}
}
}
catch (Exception)
{
throw;
}
finally
{
if (needCloseConnection)
{
this.Database.Connection.Close();
}
}
}
public string GetSQL(System.Linq.IQueryable q)
{
return(this.GetCommand(q).CommandText);
}
public void Populate()
{
#region Types of Keywords
FieldPublicDynamic = new { PropPublic1 = "A", PropPublic2 = 1, PropPublic3 = "B", PropPublic4 = "B", PropPublic5 = "B", PropPublic6 = "B", PropPublic7 = "B", PropPublic8 = "B", PropPublic9 = "B", PropPublic10 = "B", PropPublic11 = "B", PropPublic12 = new { PropSubPublic1 = 0, PropSubPublic2 = 1, PropSubPublic3 = 2 } };
FieldPublicObject = new StringBuilder("Object - StringBuilder");
FieldPublicInt32 = int.MaxValue;
FieldPublicInt64 = long.MaxValue;
FieldPublicULong = ulong.MaxValue;
FieldPublicUInt = uint.MaxValue;
FieldPublicDecimal = 100000.999999m;
FieldPublicDouble = 100000.999999d;
FieldPublicChar = 'A';
FieldPublicByte = byte.MaxValue;
FieldPublicBoolean = true;
FieldPublicSByte = sbyte.MaxValue;
FieldPublicShort = short.MaxValue;
FieldPublicUShort = ushort.MaxValue;
FieldPublicFloat = 100000.675555f;
FieldPublicInt32Nullable = int.MaxValue;
FieldPublicInt64Nullable = 2;
FieldPublicULongNullable = ulong.MaxValue;
FieldPublicUIntNullable = uint.MaxValue;
FieldPublicDecimalNullable = 100000.999999m;
FieldPublicDoubleNullable = 100000.999999d;
FieldPublicCharNullable = 'A';
FieldPublicByteNullable = byte.MaxValue;
FieldPublicBooleanNullable = true;
FieldPublicSByteNullable = sbyte.MaxValue;
FieldPublicShortNullable = short.MaxValue;
FieldPublicUShortNullable = ushort.MaxValue;
FieldPublicFloatNullable = 100000.675555f;
#endregion
#region System
FieldPublicDateTime = new DateTime(2000, 1, 1, 1, 1, 1);
FieldPublicTimeSpan = new TimeSpan(1, 10, 40);
FieldPublicEnumDateTimeKind = DateTimeKind.Local;
// Instantiate date and time using Persian calendar with years,
// months, days, hours, minutes, seconds, and milliseconds
FieldPublicDateTimeOffset = new DateTimeOffset(1387, 2, 12, 8, 6, 32, 545,
new System.Globalization.PersianCalendar(),
new TimeSpan(1, 0, 0));
FieldPublicIntPtr = new IntPtr(100);
FieldPublicTimeZone = TimeZone.CurrentTimeZone;
FieldPublicTimeZoneInfo = TimeZoneInfo.Utc;
FieldPublicTuple = Tuple.Create <string, int, decimal>("T-string\"", 1, 1.1m);
FieldPublicType = typeof(object);
FieldPublicUIntPtr = new UIntPtr(100);
FieldPublicUri = new Uri("http://www.site.com");
FieldPublicVersion = new Version(1, 0, 100, 1);
FieldPublicGuid = new Guid("d5010f5b-0cd1-44ca-aacb-5678b9947e6c");
FieldPublicSingle = Single.MaxValue;
FieldPublicException = new Exception("Test error", new Exception("inner exception"));
FieldPublicEnumNonGeneric = EnumTest.ValueA;
FieldPublicAction = () => true.Equals(true);
FieldPublicAction2 = (a, b) => true.Equals(true);
FieldPublicFunc = () => true;
FieldPublicFunc2 = (a, b) => true;
#endregion
#region Arrays and Collections
FieldPublicArrayUni = new string[2];
FieldPublicArrayUni[0] = "[0]";
FieldPublicArrayUni[1] = "[1]";
FieldPublicArrayTwo = new string[2, 2];
FieldPublicArrayTwo[0, 0] = "[0, 0]";
FieldPublicArrayTwo[0, 1] = "[0, 1]";
FieldPublicArrayTwo[1, 0] = "[1, 0]";
FieldPublicArrayTwo[1, 1] = "[1, 1]";
FieldPublicArrayThree = new string[1, 1, 2];
FieldPublicArrayThree[0, 0, 0] = "[0, 0, 0]";
FieldPublicArrayThree[0, 0, 1] = "[0, 0, 1]";
FieldPublicJaggedArrayTwo = new string[2][];
FieldPublicJaggedArrayTwo[0] = new string[5] {
"a", "b", "c", "d", "e"
};
FieldPublicJaggedArrayTwo[1] = new string[4] {
"a1", "b1", "c1", "d1"
};
FieldPublicJaggedArrayThree = new string[1][][];
FieldPublicJaggedArrayThree[0] = new string[1][];
FieldPublicJaggedArrayThree[0][0] = new string[2];
FieldPublicJaggedArrayThree[0][0][0] = "[0][0][0]";
FieldPublicJaggedArrayThree[0][0][1] = "[0][0][1]";
FieldPublicMixedArrayAndJagged = new int[3][, ]
{
new int[, ] {
{ 1, 3 }, { 5, 7 }
},
new int[, ] {
{ 0, 2 }, { 4, 6 }, { 8, 10 }
},
new int[, ] {
{ 11, 22 }, { 99, 88 }, { 0, 9 }
}
};
FieldPublicDictionary = new System.Collections.Generic.Dictionary <string, string>();
FieldPublicDictionary.Add("Key1", "Value1");
FieldPublicDictionary.Add("Key2", "Value2");
FieldPublicDictionary.Add("Key3", "Value3");
FieldPublicDictionary.Add("Key4", "Value4");
FieldPublicList = new System.Collections.Generic.List <int>();
FieldPublicList.Add(0);
FieldPublicList.Add(1);
FieldPublicList.Add(2);
FieldPublicQueue = new System.Collections.Generic.Queue <int>();
FieldPublicQueue.Enqueue(10);
FieldPublicQueue.Enqueue(11);
FieldPublicQueue.Enqueue(12);
FieldPublicHashSet = new System.Collections.Generic.HashSet <string>();
FieldPublicHashSet.Add("HashSet1");
FieldPublicHashSet.Add("HashSet2");
FieldPublicSortedSet = new System.Collections.Generic.SortedSet <string>();
FieldPublicSortedSet.Add("SortedSet1");
FieldPublicSortedSet.Add("SortedSet2");
FieldPublicSortedSet.Add("SortedSet3");
FieldPublicStack = new System.Collections.Generic.Stack <string>();
FieldPublicStack.Push("Stack1");
FieldPublicStack.Push("Stack2");
FieldPublicStack.Push("Stack3");
FieldPublicLinkedList = new System.Collections.Generic.LinkedList <string>();
FieldPublicLinkedList.AddFirst("LinkedList1");
FieldPublicLinkedList.AddLast("LinkedList2");
FieldPublicLinkedList.AddAfter(FieldPublicLinkedList.Find("LinkedList1"), "LinkedList1.1");
FieldPublicObservableCollection = new System.Collections.ObjectModel.ObservableCollection <string>();
FieldPublicObservableCollection.Add("ObservableCollection1");
FieldPublicObservableCollection.Add("ObservableCollection2");
FieldPublicKeyedCollection = new MyDataKeyedCollection();
FieldPublicKeyedCollection.Add(new MyData()
{
Data = "data1", Id = 0
});
FieldPublicKeyedCollection.Add(new MyData()
{
Data = "data2", Id = 1
});
var list = new List <string>();
list.Add("list1");
list.Add("list2");
list.Add("list3");
FieldPublicReadOnlyCollection = new ReadOnlyCollection <string>(list);
FieldPublicReadOnlyDictionary = new ReadOnlyDictionary <string, string>(FieldPublicDictionary);
FieldPublicReadOnlyObservableCollection = new ReadOnlyObservableCollection <string>(FieldPublicObservableCollection);
FieldPublicCollection = new Collection <string>();
FieldPublicCollection.Add("collection1");
FieldPublicCollection.Add("collection2");
FieldPublicCollection.Add("collection3");
FieldPublicArrayListNonGeneric = new System.Collections.ArrayList();
FieldPublicArrayListNonGeneric.Add(1);
FieldPublicArrayListNonGeneric.Add("a");
FieldPublicArrayListNonGeneric.Add(10.0m);
FieldPublicArrayListNonGeneric.Add(new DateTime(2000, 01, 01));
FieldPublicBitArray = new System.Collections.BitArray(3);
FieldPublicBitArray[2] = true;
FieldPublicSortedList = new System.Collections.SortedList();
FieldPublicSortedList.Add("key1", 1);
FieldPublicSortedList.Add("key2", 2);
FieldPublicSortedList.Add("key3", 3);
FieldPublicSortedList.Add("key4", 4);
FieldPublicHashtableNonGeneric = new System.Collections.Hashtable();
FieldPublicHashtableNonGeneric.Add("key1", 1);
FieldPublicHashtableNonGeneric.Add("key2", 2);
FieldPublicHashtableNonGeneric.Add("key3", 3);
FieldPublicHashtableNonGeneric.Add("key4", 4);
FieldPublicQueueNonGeneric = new System.Collections.Queue();
FieldPublicQueueNonGeneric.Enqueue("QueueNonGeneric1");
FieldPublicQueueNonGeneric.Enqueue("QueueNonGeneric2");
FieldPublicQueueNonGeneric.Enqueue("QueueNonGeneric3");
FieldPublicStackNonGeneric = new System.Collections.Stack();
FieldPublicStackNonGeneric.Push("StackNonGeneric1");
FieldPublicStackNonGeneric.Push("StackNonGeneric2");
FieldPublicIEnumerable = FieldPublicSortedList;
FieldPublicBlockingCollection = new System.Collections.Concurrent.BlockingCollection <string>();
FieldPublicBlockingCollection.Add("BlockingCollection1");
FieldPublicBlockingCollection.Add("BlockingCollection2");
FieldPublicConcurrentBag = new System.Collections.Concurrent.ConcurrentBag <string>();
FieldPublicConcurrentBag.Add("ConcurrentBag1");
FieldPublicConcurrentBag.Add("ConcurrentBag2");
FieldPublicConcurrentBag.Add("ConcurrentBag3");
FieldPublicConcurrentDictionary = new System.Collections.Concurrent.ConcurrentDictionary <string, int>();
FieldPublicConcurrentDictionary.GetOrAdd("ConcurrentDictionary1", 0);
FieldPublicConcurrentDictionary.GetOrAdd("ConcurrentDictionary2", 0);
FieldPublicConcurrentQueue = new System.Collections.Concurrent.ConcurrentQueue <string>();
FieldPublicConcurrentQueue.Enqueue("ConcurrentQueue1");
FieldPublicConcurrentQueue.Enqueue("ConcurrentQueue2");
FieldPublicConcurrentStack = new System.Collections.Concurrent.ConcurrentStack <string>();
FieldPublicConcurrentStack.Push("ConcurrentStack1");
FieldPublicConcurrentStack.Push("ConcurrentStack2");
// FieldPublicOrderablePartitioner = new OrderablePartitioner();
// FieldPublicPartitioner;
// FieldPublicPartitionerNonGeneric;
FieldPublicHybridDictionary = new System.Collections.Specialized.HybridDictionary();
FieldPublicHybridDictionary.Add("HybridDictionaryKey1", "HybridDictionary1");
FieldPublicHybridDictionary.Add("HybridDictionaryKey2", "HybridDictionary2");
FieldPublicListDictionary = new System.Collections.Specialized.ListDictionary();
FieldPublicListDictionary.Add("ListDictionaryKey1", "ListDictionary1");
FieldPublicListDictionary.Add("ListDictionaryKey2", "ListDictionary2");
FieldPublicNameValueCollection = new System.Collections.Specialized.NameValueCollection();
FieldPublicNameValueCollection.Add("Key1", "Value1");
FieldPublicNameValueCollection.Add("Key2", "Value2");
FieldPublicOrderedDictionary = new System.Collections.Specialized.OrderedDictionary();
FieldPublicOrderedDictionary.Add(1, "OrderedDictionary1");
FieldPublicOrderedDictionary.Add(2, "OrderedDictionary1");
FieldPublicOrderedDictionary.Add("OrderedDictionaryKey2", "OrderedDictionary2");
FieldPublicStringCollection = new System.Collections.Specialized.StringCollection();
FieldPublicStringCollection.Add("StringCollection1");
FieldPublicStringCollection.Add("StringCollection2");
#endregion
#region Several
PropXmlDocument = new XmlDocument();
PropXmlDocument.LoadXml("<xml>something</xml>");
var tr = new StringReader("<Root>Content</Root>");
PropXDocument = XDocument.Load(tr);
PropStream = GenerateStreamFromString("Stream");
PropBigInteger = new System.Numerics.BigInteger(100);
PropStringBuilder = new StringBuilder("StringBuilder");
FieldPublicIQueryable = new List <string>()
{
"IQueryable"
}.AsQueryable();
#endregion
#region Custom
FieldPublicMyCollectionPublicGetEnumerator = new MyCollectionPublicGetEnumerator("a b c", new char[] { ' ' });
FieldPublicMyCollectionInheritsPublicGetEnumerator = new MyCollectionInheritsPublicGetEnumerator("a b c", new char[] { ' ' });
FieldPublicMyCollectionExplicitGetEnumerator = new MyCollectionExplicitGetEnumerator("a b c", new char[] { ' ' });
FieldPublicMyCollectionInheritsExplicitGetEnumerator = new MyCollectionInheritsExplicitGetEnumerator("a b c", new char[] { ' ' });
FieldPublicMyCollectionInheritsTooIEnumerable = new MyCollectionInheritsTooIEnumerable("a b c", new char[] { ' ' });
FieldPublicEnumSpecific = EnumTest.ValueB;
MyDelegate = MethodDelegate;
EmptyClass = new EmptyClass();
StructGeneric = new ThreeTuple <int>(0, 1, 2);
StructGenericNullable = new ThreeTuple <int>(0, 1, 2);
FieldPublicNullable = new Nullable <ThreeTuple <int> >(StructGeneric);
#endregion
}
/// <summary>
/// 开启更新锁
/// </summary>
/// <param name="items"></param>
public void UpdateLock(System.Linq.IQueryable items)
{
if (this.Database.Connection.State != System.Data.ConnectionState.Open)
{
throw new Exception("没有开启事务");
}
Type dataType = items.GetType().GetGenericArguments()[0];
string pkid = null;
Attributes.Table tableAttr = null;
if (dataType != null)
{
try
{
tableAttr = dataType.GetTypeInfo().GetCustomAttribute(typeof(Attributes.Table)) as Attributes.Table;
if (tableAttr != null)
{
pkid = tableAttr.KeyName;
}
}
catch
{
}
}
if (pkid == null)
{
throw new Exception(dataType.Name + "没有定义主键");
}
WayDBColumnAttribute[] columns = null;
Attributes.Table.DataTypeColumns.TryGetValue(dataType, out columns);
if (columns == null)
{
var properties = dataType.GetProperties();
List <WayDBColumnAttribute> allcolumns = new List <WayDBColumnAttribute>();
foreach (var pro in properties)
{
var attr = pro.GetCustomAttribute <WayDBColumnAttribute>();
if (attr != null)
{
allcolumns.Add(attr);
}
}
Attributes.Table.DataTypeColumns[dataType] = columns = allcolumns.ToArray();
}
int pagesize = 100;
var query = InvokeSelect(items, pkid);
int skip = 0;
while (true)
{
var skipQuery = InvokeSkip(query, skip);
var data1 = InvokeTake(skipQuery, pagesize);
var dataitems = (System.Array)InvokeToArray(data1);
foreach (var idvalue in dataitems)
{
this.Database.UpdateLock(dataType.Name, columns, idvalue);
}
if (dataitems.Length < pagesize)
{
break;
}
skip += pagesize;
}
}
public void DatasourseBind(System.Linq.IQueryable linq, int CurrentPage, int PageSize, Repeater rpt)
{
}
public bool Verify(
System.Linq.IQueryable queryable,
string hostIdProp,
string hostIdValue,
string clientName,
string clientIdProp,
string clientIdValue)
{
var expHost = Expression.Parameter(typeof(TEntity), "host");
var expHostId = Expression.Call(
// get host id property value as whatever it is
Expression.Property(
expHost,
hostIdProp),
"ToString",
null);
var expHostIdValue = Expression.Constant(hostIdValue);
var expHostIdentity = Expression.Equal(expHostId, expHostIdValue);
var expClient = Expression.Property(expHost, clientName);
var expClientIdValue = Expression.Constant(clientIdValue);
if (expClient.Type.Name.StartsWith("ICollection"))
{
var clientType = expClient.Type.GenericTypeArguments.First();
var expClientParameter = Expression.Parameter(clientType, "client");
var expClientId = Expression.Call(
// get client id property value as whatever it is
Expression.Property(
expClientParameter,
clientIdProp),
"ToString",
null);
Expression expression = Expression.Equal(expClientId, expClientIdValue);
expression = Where <TTarget> (
typeof(Enumerable),
clientType,
expClient,
expression,
expClientParameter);
expression = Expression.Call(
typeof(Enumerable),
"Any",
new Type[] { clientType },
expression);
expression = Where <TEntity> (
typeof(Queryable),
queryable.ElementType,
queryable.Expression,
Expression.AndAlso(expHostIdentity, expression),
expHost);
var query = queryable.Provider
.CreateQuery <TEntity> (expression) as IQueryable <TEntity>;
return(query.Take(1).Any());
}
else
{
var expClientId = Expression.Call(
Expression.Property(expClient, clientIdProp),
"ToString",
null);
var expClientIdentity = Expression.Equal(expClientId, expClientIdValue);
var predicateBody = Expression.AndAlso(expHostIdentity, expClientIdentity);
var query = queryable.Provider.CreateQuery <TEntity> (
Where <TEntity> (
typeof(System.Linq.Queryable),
queryable.ElementType,
queryable.Expression,
predicateBody,
expHost)
) as IQueryable <TEntity>;
return(query.Take(1).Any());
}
}
public override System.Linq.Expressions.Expression BuildLinqExpression(System.Linq.IQueryable query, System.Linq.Expressions.Expression expression, System.Linq.Expressions.Expression item = null)
{
throw new NotSupportedException(
string.Format("{0} is just a placeholder and should be handled differently in Extensions.cs", this.GetType().Name));
}
