public bool TryGetTable(Type entityType, out MetaTable table)
{
CheckForRegistrationException();
if (entityType == null)
{
throw new ArgumentNullException("entityType");
}
if (!this._registerGlobally)
{
table = this.Tables.SingleOrDefault <MetaTable>(t => t.EntityType == entityType);
return(table > null);
}
return(MetaModelManager.TryGetTable(entityType, out table));
}
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);
}
}
/// <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));
}
}
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;
}
}
