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

696 lines
28 KiB
C#

using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Web.DynamicData.ModelProviders;
using System.Web.Resources;
using System.Collections.Concurrent;
namespace System.Web.DynamicData {
/// <summary>
/// Object that represents a database or a number of databases used by the dynamic data. It can have multiple different data contexts registered on it.
/// </summary>
public class MetaModel : IMetaModel {
private List<Type> _contextTypes = new List<Type>();
private static object _lock = new object();
private List<MetaTable> _tables = new List<MetaTable>();
private ReadOnlyCollection<MetaTable> _tablesRO;
private Dictionary<string, MetaTable> _tablesByUniqueName = new Dictionary<string, MetaTable>(StringComparer.OrdinalIgnoreCase);
private Dictionary<ContextTypeTableNamePair, MetaTable> _tablesByContextAndName = new Dictionary<ContextTypeTableNamePair, MetaTable>();
private SchemaCreator _schemaCreator;
private EntityTemplateFactory _entityTemplateFactory;
private IFieldTemplateFactory _fieldTemplateFactory;
private FilterFactory _filterFactory;
private static Exception s_registrationException;
private static MetaModel s_defaultModel;
private string _dynamicDataFolderVirtualPath;
private HttpContextBase _context;
private readonly static ConcurrentDictionary<Type, bool> s_registeredMetadataTypes = new ConcurrentDictionary<Type, bool>();
// Use global registration is true by default
private bool _registerGlobally = true;
internal virtual int RegisteredDataModelsCount {
get {
return _contextTypes.Count;
}
}
/// <summary>
/// ctor
/// </summary>
public MetaModel()
: this(true /* registerGlobally */) {
}
public MetaModel(bool registerGlobally)
: this(SchemaCreator.Instance, registerGlobally) {
}
// constructor for testing purposes
internal MetaModel(SchemaCreator schemaCreator, bool registerGlobally) {
// Create a readonly wrapper for handing out
_tablesRO = new ReadOnlyCollection<MetaTable>(_tables);
_schemaCreator = schemaCreator;
_registerGlobally = registerGlobally;
// Don't touch Default.Model when we're not using global registration
if (registerGlobally) {
lock (_lock) {
if (Default == null) {
Default = this;
}
}
}
}
internal HttpContextBase Context {
get {
return _context ?? HttpContext.Current.ToWrapper();
}
set {
_context = value;
}
}
/// <summary>
/// allows for setting of the DynamicData folder for this mode. The default is ~/DynamicData/
/// </summary>
public string DynamicDataFolderVirtualPath {
get {
if (_dynamicDataFolderVirtualPath == null) {
_dynamicDataFolderVirtualPath = "~/DynamicData/";
}
return _dynamicDataFolderVirtualPath;
}
set {
// Make sure it ends with a slash
_dynamicDataFolderVirtualPath = VirtualPathUtility.AppendTrailingSlash(value);
}
}
/// <summary>
/// Returns a reference to the first instance of MetaModel that is created in an app. Provides a simple way of referencing
/// the default MetaModel instance. Applications that will use multiple models will have to provide their own way of storing
/// references to any additional meta models. One way of looking them up is by using the GetModel method.
/// </summary>
public static MetaModel Default {
get {
CheckForRegistrationException();
return s_defaultModel;
}
internal set { s_defaultModel = value; }
}
/// <summary>
/// Gets the model instance that had the contextType registered with it
/// </summary>
/// <param name="contextType">A DataContext or ObjectContext type (e.g. NorthwindDataContext)</param>
/// <returns>a model</returns>
public static MetaModel GetModel(Type contextType) {
CheckForRegistrationException();
if (contextType == null) {
throw new ArgumentNullException("contextType");
}
MetaModel model;
if (MetaModelManager.TryGetModel(contextType, out model)) {
return model;
}
else {
throw new InvalidOperationException(String.Format(
CultureInfo.CurrentCulture,
DynamicDataResources.MetaModel_ContextDoesNotBelongToModel,
contextType.FullName));
}
}
/// <summary>
/// Registers a context. Uses the default ContextConfiguration options.
/// </summary>
/// <param name="contextType"></param>
public void RegisterContext(Type contextType) {
RegisterContext(contextType, new ContextConfiguration());
}
/// <summary>
/// Registers a context. Uses the the given ContextConfiguration options.
/// </summary>
/// <param name="contextType"></param>
/// <param name="configuration"></param>
public void RegisterContext(Type contextType, ContextConfiguration configuration) {
if (contextType == null) {
throw new ArgumentNullException("contextType");
}
RegisterContext(() => Activator.CreateInstance(contextType), configuration);
}
/// <summary>
/// Registers a context. Uses default ContextConfiguration. Accepts a context factory that is a delegate used for
/// instantiating the context. This allows developers to instantiate context using a custom constructor.
/// </summary>
/// <param name="contextFactory"></param>
public void RegisterContext(Func<object> contextFactory) {
RegisterContext(contextFactory, new ContextConfiguration());
}
/// <summary>
/// Registers a context. Uses given ContextConfiguration. Accepts a context factory that is a delegate used for
/// instantiating the context. This allows developers to instantiate context using a custom constructor.
/// </summary>
/// <param name="contextFactory"></param>
/// <param name="configuration"></param>
public void RegisterContext(Func<object> contextFactory, ContextConfiguration configuration) {
object contextInstance = null;
try {
if (contextFactory == null) {
throw new ArgumentNullException("contextFactory");
}
contextInstance = contextFactory();
if (contextInstance == null) {
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, DynamicDataResources.MetaModel_ContextFactoryReturnsNull), "contextFactory");
}
Type contextType = contextInstance.GetType();
if (!_schemaCreator.ValidDataContextType(contextType)) {
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, DynamicDataResources.MetaModel_ContextTypeNotSupported, contextType.FullName));
}
}
catch (Exception e) {
s_registrationException = e;
throw;
}
// create model abstraction
RegisterContext(_schemaCreator.CreateDataModel(contextInstance, contextFactory), configuration);
}
/// <summary>
/// Register context using give model provider. Uses default context configuration.
/// </summary>
/// <param name="dataModelProvider"></param>
public void RegisterContext(DataModelProvider dataModelProvider) {
RegisterContext(dataModelProvider, new ContextConfiguration());
}
/// <summary>
/// Register context using give model provider. Uses given context configuration.
/// </summary>
/// <param name="dataModelProvider"></param>
/// <param name="configuration"></param>
[SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces",
Justification = "Interface is not used in any security sesitive code paths.")]
public virtual void RegisterContext(DataModelProvider dataModelProvider, ContextConfiguration configuration) {
if (dataModelProvider == null) {
throw new ArgumentNullException("dataModelProvider");
}
if (configuration == null) {
throw new ArgumentNullException("configuration");
}
if (_registerGlobally) {
CheckForRegistrationException();
}
// check if context has already been registered
if (_contextTypes.Contains(dataModelProvider.ContextType)) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, DynamicDataResources.MetaModel_ContextAlreadyRegistered, dataModelProvider.ContextType.FullName));
}
try {
IEnumerable<TableProvider> tableProviders = dataModelProvider.Tables;
// create and validate model
var tablesToInitialize = new List<MetaTable>();
foreach (TableProvider tableProvider in tableProviders) {
RegisterMetadataTypeDescriptionProvider(tableProvider, configuration.MetadataProviderFactory);
MetaTable table = CreateTable(tableProvider);
table.CreateColumns();
var tableNameAttribute = tableProvider.Attributes.OfType<TableNameAttribute>().SingleOrDefault();
string nameOverride = tableNameAttribute != null ? tableNameAttribute.Name : null;
table.SetScaffoldAndName(configuration.ScaffoldAllTables, nameOverride);
CheckTableNameConflict(table, nameOverride, tablesToInitialize);
tablesToInitialize.Add(table);
}
_contextTypes.Add(dataModelProvider.ContextType);
if (_registerGlobally) {
MetaModelManager.AddModel(dataModelProvider.ContextType, this);
}
foreach (MetaTable table in tablesToInitialize) {
AddTable(table);
}
// perform initialization at the very end to ensure all references will be properly registered
foreach (MetaTable table in tablesToInitialize) {
table.Initialize();
}
}
catch (Exception e) {
if (_registerGlobally) {
s_registrationException = e;
}
throw;
}
}
internal static void CheckForRegistrationException() {
if (s_registrationException != null) {
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture, DynamicDataResources.MetaModel_RegistrationErrorOccurred),
s_registrationException);
}
}
/// <summary>
/// Reset any previous registration error that may have happened. Normally, the behavior is that when an error
/// occurs during registration, the exception is cached and rethrown on all subsequent operations. This is done
/// so that if an error occurs in Application_Start, it shows up on every request. Calling this method clears
/// out the error and potentially allows new RegisterContext calls.
/// </summary>
public static void ResetRegistrationException() {
s_registrationException = null;
}
// Used for unit tests
internal static void ClearSimpleCache() {
s_registeredMetadataTypes.Clear();
}
internal static MetaModel CreateSimpleModel(Type entityType) {
// Never register a TDP more than once for a type
if (!s_registeredMetadataTypes.ContainsKey(entityType)) {
var provider = new AssociatedMetadataTypeTypeDescriptionProvider(entityType);
TypeDescriptor.AddProviderTransparent(provider, entityType);
s_registeredMetadataTypes.TryAdd(entityType, true);
}
MetaModel model = new MetaModel(false /* registerGlobally */);
// Pass a null provider factory since we registered the provider ourselves
model.RegisterContext(new SimpleDataModelProvider(entityType), new ContextConfiguration { MetadataProviderFactory = null });
return model;
}
internal static MetaModel CreateSimpleModel(ICustomTypeDescriptor descriptor) {
MetaModel model = new MetaModel(false /* registerGlobally */);
//
model.RegisterContext(new SimpleDataModelProvider(descriptor));
return model;
}
/// <summary>
/// Instantiate a MetaTable object. Can be overridden to instantiate a derived type
/// </summary>
/// <returns></returns>
protected virtual MetaTable CreateTable(TableProvider provider) {
return new MetaTable(this, provider);
}
private void AddTable(MetaTable table) {
_tables.Add(table);
_tablesByUniqueName.Add(table.Name, table);
if (_registerGlobally) {
MetaModelManager.AddTable(table.EntityType, table);
}
if (table.DataContextType != null) {
// need to use the name from the provider since the name from the table could have been modified by use of TableNameAttribute
_tablesByContextAndName.Add(new ContextTypeTableNamePair(table.DataContextType, table.Provider.Name), table);
}
}
private void CheckTableNameConflict(MetaTable table, string nameOverride, List<MetaTable> tablesToInitialize) {
// try to find name conflict in tables from other context, or already processed tables in current context
MetaTable nameConflictTable;
if (!_tablesByUniqueName.TryGetValue(table.Name, out nameConflictTable)) {
nameConflictTable = tablesToInitialize.Find(t => t.Name.Equals(table.Name, StringComparison.CurrentCulture));
}
if (nameConflictTable != null) {
if (String.IsNullOrEmpty(nameOverride)) {
throw new ArgumentException(String.Format(
CultureInfo.CurrentCulture,
DynamicDataResources.MetaModel_EntityNameConflict,
table.EntityType.FullName,
table.DataContextType.FullName,
nameConflictTable.EntityType.FullName,
nameConflictTable.DataContextType.FullName));
}
else {
throw new ArgumentException(String.Format(
CultureInfo.CurrentCulture,
DynamicDataResources.MetaModel_EntityNameOverrideConflict,
nameOverride,
table.EntityType.FullName,
table.DataContextType.FullName,
nameConflictTable.EntityType.FullName,
nameConflictTable.DataContextType.FullName));
}
}
}
private static void RegisterMetadataTypeDescriptionProvider(TableProvider entity, Func<Type, TypeDescriptionProvider> providerFactory) {
if (providerFactory != null) {
Type entityType = entity.EntityType;
// Support for type-less MetaTable
if (entityType != null) {
TypeDescriptionProvider provider = providerFactory(entityType);
if (provider != null) {
TypeDescriptor.AddProviderTransparent(provider, entityType);
}
}
}
}
/// <summary>
/// Returns a collection of all the tables that are part of the context, regardless of whether they are visible or not.
/// </summary>
public ReadOnlyCollection<MetaTable> Tables {
get {
CheckForRegistrationException();
return _tablesRO;
}
}
/// <summary>
/// Returns a collection of the currently visible tables for this context. Currently visible is defined as:
/// - a table whose EntityType is not abstract
/// - a table with scaffolding enabled
/// - a table for which a custom page for the list action can be found and that can be read by the current User
/// </summary>
public List<MetaTable> VisibleTables {
get {
CheckForRegistrationException();
return Tables.Where(IsTableVisible).OrderBy(t => t.DisplayName).ToList();
}
}
private bool IsTableVisible(MetaTable table) {
return !table.EntityType.IsAbstract && !String.IsNullOrEmpty(table.ListActionPath) && table.CanRead(Context.User);
}
/// <summary>
/// Looks up a MetaTable by the entity type. Throws an exception if one is not found.
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "We really want this to be a Type.")]
public MetaTable GetTable(Type entityType) {
MetaTable table;
if (!TryGetTable(entityType, out table)) {
throw new ArgumentException(String.Format(
CultureInfo.CurrentCulture,
DynamicDataResources.MetaModel_UnknownEntityType,
entityType.FullName));
}
return table;
}
/// <summary>
/// Tries to look up a MetaTable by the entity type.
/// </summary>
/// <param name="entityType"></param>
/// <param name="table"></param>
/// <returns></returns>
public bool TryGetTable(Type entityType, out MetaTable table) {
CheckForRegistrationException();
if (entityType == null) {
throw new ArgumentNullException("entityType");
}
if (!_registerGlobally) {
table = Tables.SingleOrDefault(t => t.EntityType == entityType);
return table != null;
}
return MetaModelManager.TryGetTable(entityType, out table);
}
/// <summary>
/// Looks up a MetaTable by unique name. Throws if one is not found. The unique name defaults to the table name, or an override
/// can be provided via ContextConfiguration when the context that contains the table is registered. The unique name uniquely
/// identifies a table within a give MetaModel. It is used for URL generation.
/// </summary>
/// <param name="uniqueTableName"></param>
/// <returns></returns>
public MetaTable GetTable(string uniqueTableName) {
CheckForRegistrationException();
MetaTable table;
if (!TryGetTable(uniqueTableName, out table)) {
throw new ArgumentException(String.Format(
CultureInfo.CurrentCulture,
DynamicDataResources.MetaModel_UnknownTable,
uniqueTableName));
}
return table;
}
/// <summary>
/// Tries to look up a MetaTable by unique name. Doe
/// </summary>
/// <param name="uniqueTableName"></param>
/// <param name="table"></param>
/// <returns></returns>
public bool TryGetTable(string uniqueTableName, out MetaTable table) {
CheckForRegistrationException();
if (uniqueTableName == null) {
throw new ArgumentNullException("uniqueTableName");
}
return _tablesByUniqueName.TryGetValue(uniqueTableName, out table);
}
/// <summary>
/// Looks up a MetaTable by the contextType/tableName combination. Throws if one is not found.
/// </summary>
/// <param name="tableName"></param>
/// <param name="contextType"></param>
/// <returns></returns>
public MetaTable GetTable(string tableName, Type contextType) {
CheckForRegistrationException();
if (tableName == null) {
throw new ArgumentNullException("tableName");
}
if (contextType == null) {
throw new ArgumentNullException("contextType");
}
MetaTable table;
if (!_tablesByContextAndName.TryGetValue(new ContextTypeTableNamePair(contextType, tableName), out table)) {
if (!_contextTypes.Contains(contextType)) {
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.MetaModel_UnknownContextType,
contextType.FullName));
}
else {
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
DynamicDataResources.MetaModel_UnknownTableInContext,
contextType.FullName,
tableName));
}
}
return table;
}
/// <summary>
/// Lets you set a custom IFieldTemplateFactory. An IFieldTemplateFactor lets you customize which field templates are created
/// for the various columns.
/// </summary>
public IFieldTemplateFactory FieldTemplateFactory {
get {
// If no custom factory was set, use our default
if (_fieldTemplateFactory == null) {
FieldTemplateFactory = new FieldTemplateFactory();
}
return _fieldTemplateFactory;
}
set {
_fieldTemplateFactory = value;
// Give the model to the factory
if (_fieldTemplateFactory != null) {
_fieldTemplateFactory.Initialize(this);
}
}
}
public EntityTemplateFactory EntityTemplateFactory {
get {
if (_entityTemplateFactory == null) {
EntityTemplateFactory = new EntityTemplateFactory();
}
return _entityTemplateFactory;
}
set {
_entityTemplateFactory = value;
if (_entityTemplateFactory != null) {
_entityTemplateFactory.Initialize(this);
}
}
}
public FilterFactory FilterFactory {
get {
if (_filterFactory == null) {
FilterFactory = new FilterFactory();
}
return _filterFactory;
}
set {
_filterFactory = value;
if (_filterFactory != null) {
_filterFactory.Initialize(this);
}
}
}
private string _queryStringKeyPrefix = String.Empty;
/// <summary>
/// Lets you get an action path (URL) to an action for a particular table/action/entity instance combo.
/// </summary>
/// <param name="tableName"></param>
/// <param name="action"></param>
/// <param name="row">An object representing a single row of data in a table. Used to provide values for query string parameters.</param>
/// <returns></returns>
public string GetActionPath(string tableName, string action, object row) {
return GetTable(tableName).GetActionPath(action, row);
}
private class ContextTypeTableNamePair : IEquatable<ContextTypeTableNamePair> {
public ContextTypeTableNamePair(Type contextType, string tableName) {
Debug.Assert(contextType != null);
Debug.Assert(tableName != null);
ContextType = contextType;
TableName = tableName;
HashCode = ContextType.GetHashCode() ^ TableName.GetHashCode();
}
private int HashCode { get; set; }
public Type ContextType { get; private set; }
public string TableName { get; private set; }
public bool Equals(ContextTypeTableNamePair other) {
if (other == null) {
return false;
}
return ContextType == other.ContextType && TableName.Equals(other.TableName, StringComparison.Ordinal);
}
public override int GetHashCode() {
return HashCode;
}
public override bool Equals(object obj) {
return Equals(obj as ContextTypeTableNamePair);
}
}
internal static class MetaModelManager {
private static Hashtable s_modelByContextType = new Hashtable();
private static Hashtable s_tableByEntityType = new Hashtable();
internal static void AddModel(Type contextType, MetaModel model) {
Debug.Assert(contextType != null);
Debug.Assert(model != null);
lock (s_modelByContextType) {
s_modelByContextType.Add(contextType, model);
}
}
internal static bool TryGetModel(Type contextType, out MetaModel model) {
model = (MetaModel)s_modelByContextType[contextType];
return model != null;
}
internal static void AddTable(Type entityType, MetaTable table) {
Debug.Assert(entityType != null);
Debug.Assert(table != null);
lock (s_tableByEntityType) {
s_tableByEntityType[entityType] = table;
}
}
internal static void Clear() {
lock (s_modelByContextType) {
s_modelByContextType.Clear();
}
lock (s_tableByEntityType) {
s_tableByEntityType.Clear();
}
}
internal static bool TryGetTable(Type type, out MetaTable table) {
table = (MetaTable)s_tableByEntityType[type];
return table != null;
}
}
ReadOnlyCollection<IMetaTable> IMetaModel.Tables {
get {
return Tables.OfType<IMetaTable>().ToList().AsReadOnly();
}
}
bool IMetaModel.TryGetTable(string uniqueTableName, out IMetaTable table) {
MetaTable metaTable;
table = null;
if (TryGetTable(uniqueTableName, out metaTable)) {
table = metaTable;
return true;
}
return false;
}
bool IMetaModel.TryGetTable(Type entityType, out IMetaTable table) {
MetaTable metaTable;
table = null;
if (TryGetTable(entityType, out metaTable)) {
table = metaTable;
return true;
}
return false;
}
List<IMetaTable> IMetaModel.VisibleTables {
get {
return VisibleTables.OfType<IMetaTable>().ToList();
}
}
IMetaTable IMetaModel.GetTable(string tableName, Type contextType) {
return GetTable(tableName, contextType);
}
IMetaTable IMetaModel.GetTable(string uniqueTableName) {
return GetTable(uniqueTableName);
}
IMetaTable IMetaModel.GetTable(Type entityType) {
return GetTable(entityType);
}
}
}