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

356 lines
14 KiB
C#

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Web.DynamicData.Util;
using System.Web.Resources;
using System.Web.Routing;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace System.Web.DynamicData {
internal static class Misc {
public static HttpContextWrapper ToWrapper(this HttpContext context) {
return new HttpContextWrapper(context);
}
public static object GetRealDataItem(object dataItem) {
if (dataItem is ICustomTypeDescriptor) {
// Unwrap EF object
dataItem = ((ICustomTypeDescriptor)dataItem).GetPropertyOwner(null);
}
return dataItem;
}
// Walks the type hierachy up to endingType (assuming startingType is a subtype of starting type)
// trying to find a meta table.
public static MetaTable GetTableFromTypeHierarchy(Type entityType) {
if (entityType == null) {
throw new ArgumentNullException("entityType");
}
Type type = entityType;
while (type != null) {
MetaTable table;
if (MetaTable.TryGetTable(type, out table)) {
return table;
}
type = type.BaseType;
}
return null;
}
public static Type RemoveNullableFromType(Type type) {
return Nullable.GetUnderlyingType(type) ?? type;
}
internal static bool IsColumnInDictionary(IMetaColumn column, IDictionary<string, object> values) {
if (column == null) {
throw new ArgumentNullException("column");
}
if (values == null) {
throw new ArgumentNullException("values");
}
IMetaForeignKeyColumn foreignKeyColumn = column as IMetaForeignKeyColumn;
if (foreignKeyColumn != null) {
return foreignKeyColumn.ForeignKeyNames.All(fkName => values.ContainsKey(fkName));
}
return values.ContainsKey(column.Name);
}
internal static IDictionary<string, object> ConvertObjectToDictionary(object instance) {
if (instance == null) {
throw new ArgumentNullException("instance");
}
Dictionary<string, object> values = new Dictionary<string, object>();
var props = TypeDescriptor.GetProperties(instance);
foreach (PropertyDescriptor p in props) {
values[p.Name] = p.GetValue(instance);
}
return values;
}
public static T ChangeType<T>(object value) {
return (T)ChangeType(value, typeof(T));
}
public static object ChangeType(object value, Type type) {
if (type == null) {
throw new ArgumentNullException("type");
}
if (value == null) {
if (TypeAllowsNull(type)) {
return null;
}
return Convert.ChangeType(value, type, CultureInfo.CurrentCulture);
}
type = RemoveNullableFromType(type);
if (value.GetType() == type) {
return value;
}
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter.CanConvertFrom(value.GetType())) {
return converter.ConvertFrom(value);
}
TypeConverter otherConverter = TypeDescriptor.GetConverter(value.GetType());
if (otherConverter.CanConvertTo(type)) {
return otherConverter.ConvertTo(value, type);
}
throw new InvalidOperationException(String.Format(
CultureInfo.CurrentCulture,
DynamicDataResources.Misc_CannotConvertType, value.GetType(), type));
}
internal static bool TypeAllowsNull(Type type) {
return Nullable.GetUnderlyingType(type) != null || !type.IsValueType;
}
public static ContainerType FindContainerType(Control control) {
if (control == null) {
throw new ArgumentNullException("control");
}
Control container = control;
// Walk up NamingContainers until we find one of the DataBound control interfaces
while (container != null) {
if (container is IDataBoundItemControl) {
return ContainerType.Item;
}
else if (container is IDataBoundListControl || container is Repeater) {
return ContainerType.List;
}
container = container.NamingContainer;
}
// Default container type is a list if none of the known
// interfaces are found
return ContainerType.List;
}
public static IOrderedDictionary GetEnumNamesAndValues(Type enumType) {
Debug.Assert(enumType != null);
Debug.Assert(enumType.IsEnum);
OrderedDictionary result = new OrderedDictionary();
var enumEntries = from e in Enum.GetValues(enumType).OfType<object>()
select new EnumEntry {
//
Name = Enum.GetName(enumType, e),
UnderlyingValue = GetUnderlyingTypeValue(enumType, e)
};
foreach (var entry in enumEntries.OrderBy(e => e.UnderlyingValue)) {
result.Add(entry.Name, entry.UnderlyingValue.ToString());
}
return result;
}
private struct EnumEntry {
public string Name { get; set; }
public object UnderlyingValue { get; set; }
}
public static object GetUnderlyingTypeValue(Type enumType, object enumValue) {
return Convert.ChangeType(enumValue, Enum.GetUnderlyingType(enumType), CultureInfo.InvariantCulture);
}
public static string GetUnderlyingTypeValueString(Type enumType, object enumValue) {
return GetUnderlyingTypeValue(enumType, enumValue).ToString();
}
public static string PersistListToCommaSeparatedString(IList<object> list) {
// Special case empty and single lists
if (list == null || list.Count == 0)
return String.Empty;
if (list.Count == 1) {
return list[0] == null ? String.Empty : list[0].ToString().TrimEnd();
}
var builder = new StringBuilder();
bool first = true;
bool hasNonNullItem = false;
foreach (object o in list) {
if (!first) {
builder.Append(",");
}
if (o != null) {
//
builder.Append(o.ToString().TrimEnd());
hasNonNullItem = true;
}
first = false;
}
// If all the parts are null, return empty string instead of the comma separated list
if (!hasNonNullItem)
return String.Empty;
return builder.ToString();
}
//
public static object[] GetKeyValues(IList<MetaColumn> keyMembers, object entity) {
object[] values = new object[keyMembers.Count];
int index = 0;
foreach (MetaColumn pkMember in keyMembers) {
values[index++] = DataBinder.GetPropertyValue(entity, pkMember.Name);
}
return values;
}
public static string[] ParseCommaSeparatedString(string stringList) {
//
return stringList.Split(',');
}
public static IQueryable BuildSortQueryable(IQueryable query, IMetaTable table) {
IMetaColumn sortColumn = table.SortColumn;
if (sortColumn.IsCustomProperty) {
// An extra property can't be optimized on server
//
var data = query.OfType<object>().AsEnumerable();
Func<object, object> lambda = row => DataBinder.GetPropertyValue(row, sortColumn.Name);
if (table.SortDescending) {
query = data.OrderByDescending<object, object>(lambda).AsQueryable();
}
else {
query = data.OrderBy<object, object>(lambda).AsQueryable();
}
}
else {
// Build custom expression to optimize sorting on server
//
var parameter = Expression.Parameter(query.ElementType, "row");
LambdaExpression lambda = null;
IMetaForeignKeyColumn foreignKeyColumn = sortColumn as IMetaForeignKeyColumn;
if (foreignKeyColumn != null) {
// e.g. product => product.Category.CategoryName
var foreignKeySortColumn = foreignKeyColumn.ParentTable.SortColumn;
lambda = Expression.Lambda(Expression.Property(Expression.Property(parameter, sortColumn.Name), foreignKeySortColumn.Name), parameter);
}
else {
// e.g. product => product.ProductName
lambda = Expression.Lambda(Expression.Property(parameter, sortColumn.Name), parameter);
}
string ordering = table.SortDescending ? "OrderByDescending" : "OrderBy";
var expression = Expression.Call(typeof(Queryable), ordering, new Type[] { query.ElementType, lambda.Body.Type }, query.Expression, lambda);
query = query.Provider.CreateQuery(expression);
}
return query;
}
// Fill a ListItemCollection with all the entries from a table
public static void FillListItemCollection(IMetaTable table, ListItemCollection listItemCollection) {
foreach (var o in table.GetQuery()) {
string text = table.GetDisplayString(o);
string value = table.GetPrimaryKeyString(o);
listItemCollection.Add(new ListItem(text, value.TrimEnd()));
}
}
internal static void ExtractValuesFromBindableControls(IOrderedDictionary dictionary, Control container) {
IBindableControl bindableControl = container as IBindableControl;
if (bindableControl != null) {
bindableControl.ExtractValues(dictionary);
}
foreach (Control childControl in container.Controls) {
ExtractValuesFromBindableControls(dictionary, childControl);
}
}
/// <devdoc>
/// Walks up the stack of NamingContainers starting at 'control' to find a control with the ID 'controlID'.
/// Copied from DataBoundControlHelper.FindControl (System.Web)
/// </devdoc>
public static Control FindControl(Control control, string controlID) {
Debug.Assert(control != null, "control should not be null");
//Debug.Assert(!String.IsNullOrEmpty(controlID), "controlID should not be empty");
Control currentContainer = control;
Control foundControl = null;
if (control == control.Page) {
// If we get to the Page itself while we're walking up the
// hierarchy, just return whatever item we find (if anything)
// since we can't walk any higher.
return control.FindControl(controlID);
}
while (foundControl == null && currentContainer != control.Page) {
currentContainer = currentContainer.NamingContainer;
if (currentContainer == null) {
throw new HttpException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.Misc_NoNamingContainer,
control.GetType().Name, control.ID));
}
foundControl = currentContainer.FindControl(controlID);
}
return foundControl;
}
public static string GetRouteValue(string key) {
RequestContext requestContext = DynamicDataRouteHandler.GetRequestContext(HttpContext.Current);
object value;
if (!requestContext.RouteData.Values.TryGetValue(key, out value)) {
return null;
}
return value as string;
}
public static string SanitizeQueryStringValue(object value) {
if (value == null)
return null;
string strValue = value.ToString();
// Trim trailing spaces, as they are typically meaningless, and make the url look ugly
return strValue.TrimEnd();
}
internal static long CombineHashCodes(object o1, object o2) {
// Start with a seed (obtained from String.GetHashCode implementation)
long combinedHash = 5381;
combinedHash = AddHashCode(combinedHash, o1);
combinedHash = AddHashCode(combinedHash, o2);
return combinedHash;
}
// Return a single hash code for 3 objects
internal static long CombineHashCodes(object o1, object o2, object o3) {
// Start with a seed (obtained from String.GetHashCode implementation)
long combinedHash = 5381;
combinedHash = AddHashCode(combinedHash, o1);
combinedHash = AddHashCode(combinedHash, o2);
combinedHash = AddHashCode(combinedHash, o3);
return combinedHash;
}
private static long AddHashCode(long currentHash, object o) {
if (o == null)
return currentHash;
return ((currentHash << 5) + currentHash) ^ o.GetHashCode();
}
}
}