mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
356 lines
14 KiB
C#
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();
|
|
}
|
|
}
|
|
}
|
|
|