internal static DbSpatialServices GetSpatialServices(IDbDependencyResolver resolver, EntityConnection connection)
{
DebugCheck.NotNull(resolver);
DebugCheck.NotNull(connection);
var storeItemCollection = (StoreItemCollection)connection.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace);
var key = new DbProviderInfo(
storeItemCollection.ProviderInvariantName, storeItemCollection.ProviderManifestToken);
return(GetSpatialServices(resolver, key, () => GetProviderServices(connection.StoreConnection)));
}
public void SetSpatialProvider_with_key_delegates_to_internal_configuration()
{
var mockInternalConfiguration = new Mock <InternalConfiguration>(null, null, null, null);
var provider = SqlSpatialServices.Instance;
var key = new DbProviderInfo("A.Little.Time", "Paul");
new DbConfiguration(mockInternalConfiguration.Object).AddDbSpatialServices(key, provider);
mockInternalConfiguration.Verify(m => m.RegisterSingleton <DbSpatialServices>(provider, key));
}
/// <inheritdoc />
public virtual void Apply(ComplexType item, DbModel model)
{
Check.NotNull <ComplexType>(item, nameof(item));
Check.NotNull <DbModel>(model, nameof(model));
DbProviderInfo providerInfo = model.ProviderInfo;
if (providerInfo == null || !providerInfo.IsSqlCe())
{
return;
}
this.SetLength((IEnumerable <EdmProperty>)item.Properties);
}
public static StoreItemCollection GetStoreItemCollection(this XDocument model, out DbProviderInfo providerInfo)
{
DebugCheck.NotNull(model);
var schemaElement = model.Descendants(EdmXNames.Ssdl.SchemaNames).Single();
providerInfo = new DbProviderInfo(
schemaElement.ProviderAttribute(),
schemaElement.ProviderManifestTokenAttribute());
return(new StoreItemCollection(new[] { schemaElement.CreateReader() }));
}
public void GetSpatialServices_uses_resolver_to_obtain_provider_specific_spatial_services()
{
var mockSpatialServices = new Mock <DbSpatialServices>();
var mockResolver = new Mock <IDbDependencyResolver>();
var key = new DbProviderInfo("Pefect.Day", "Lou");
mockResolver.Setup(m => m.GetService(typeof(DbSpatialServices), key)).Returns(mockSpatialServices.Object);
Assert.Same(
mockSpatialServices.Object,
new Mock <DbProviderServices>((Func <IDbDependencyResolver>)(() => mockResolver.Object)).Object.GetSpatialServices(key));
}
/// <summary>
/// Builds and stores the workspace based on the given code first configuration.
/// </summary>
/// <param name="databaseMapping"> The code first EDM model. </param>
public CodeFirstCachedMetadataWorkspace(DbDatabaseMapping databaseMapping)
{
DebugCheck.NotNull(databaseMapping);
_providerInfo = databaseMapping.ProviderInfo;
_metadataWorkspace = databaseMapping.ToMetadataWorkspace();
_assemblies = databaseMapping.Model.GetClrTypes().Select(t => t.Assembly).Distinct().ToList();
Debug.Assert(databaseMapping.Model.Containers.Count() == 1, "Expecting Code First to create only one container.");
_defaultContainerName = databaseMapping.Model.Containers.First().Name;
}
private static DbSpatialServices GetSpatialServices(
IDbDependencyResolver resolver,
DbProviderInfo key,
Func <DbProviderServices> providerServices)
{
DbSpatialServices orAdd = DbProviderServices._spatialServices.GetOrAdd(key, (Func <DbProviderInfo, DbSpatialServices>)(k => resolver.GetService <DbSpatialServices>((object)k) ?? providerServices().GetSpatialServices(k.ProviderManifestToken) ?? resolver.GetService <DbSpatialServices>()));
if (orAdd == null)
{
throw new ProviderIncompatibleException(Strings.ProviderDidNotReturnSpatialServices);
}
return(orAdd);
}
public static CodeFirstCachedMetadataWorkspace Create(
StorageMappingItemCollection mappingItemCollection, DbProviderInfo providerInfo)
{
var conceptualModel = mappingItemCollection.EdmItemCollection;
var entityClrTypes = conceptualModel.GetItems <EntityType>().Select(et => et.GetClrType());
var complexClrTypes = conceptualModel.GetItems <ComplexType>().Select(ct => ct.GetClrType());
return(new CodeFirstCachedMetadataWorkspace(
mappingItemCollection.Workspace,
entityClrTypes.Union(complexClrTypes).Select(t => t.Assembly()).Distinct().ToArray(),
providerInfo,
conceptualModel.GetItems <EntityContainer>().Single().Name));
}
static DbCompiledModel CreateModel()
{
var builder = new DbModelBuilder();
builder.Conventions.Remove <PluralizingTableNameConvention>();
builder.Entity <Language>().HasKey(m => m.Name);
builder.Entity <EntityTranslationDbEntry>();
var providerInfo = new DbProviderInfo(SqlCeProviderServices.ProviderInvariantName, "4.0");
return(builder.Build(providerInfo).Compile());
}
internal static EdmModel CreateStoreModel(
DbProviderInfo providerInfo, DbProviderManifest providerManifest,
double schemaVersion = XmlConstants.SchemaVersionLatest)
{
DebugCheck.NotNull(providerInfo);
DebugCheck.NotNull(providerManifest);
return
(new EdmModel(DataSpace.SSpace, schemaVersion)
{
ProviderInfo = providerInfo,
ProviderManifest = providerManifest
});
}
private void OnProviderChange()
{
DbProviderInfo dbProvider = dbProvidersComboBox.SelectedItem as DbProviderInfo;
if (dbProvider != null)
{
fullTextCheckBox.Enabled = dbProvider.InvariantName == "System.Data.SqlClient";
if (dbProvider.InvariantName != "System.Data.SqlClient")
{
fullTextCheckBox.Checked = false;
}
Settings.Default.ProviderName = dbProvider.Name;
}
}
public static DbProviderInfo GetProviderInfo(
this DbConnection connection, out DbProviderManifest providerManifest)
{
DebugCheck.NotNull(connection);
var providerManifestToken = DbConfiguration
.GetService <IManifestTokenService>()
.GetProviderManifestToken(connection);
var providerInfo = new DbProviderInfo(connection.GetProviderInvariantName(), providerManifestToken);
providerManifest = DbProviderServices.GetProviderServices(connection).GetProviderManifest(providerManifestToken);
return(providerInfo);
}
static void Main(string[] args)
{
var mb = new DbModelBuilder();
mb.RegisterEntityType(typeof(Foo));
var pinfo = new DbProviderInfo("System.Data.SqlClient", "2008");
var ctx = new DbContext("Server=.;Database=Flange;Integrated Security=SSPI;",
mb.Build(pinfo).Compile());
ctx.Set <Foo>().Add(new Foo {
ID = 1
});
ctx.SaveChanges();
Console.ReadKey();
}
private void UpdateConnectionString()
{
if (_isConnectionStringUpdating)
{
return;
}
using (new DisposableToken <ConnectionStringBuilder>(this, x => x.Instance._isConnectionStringUpdating = true,
x => x.Instance._isConnectionStringUpdating = false))
{
var providerName = DatabaseProvider;
var connectionString = ConnectionString;
var providers = DbProvider.GetRegisteredProviders();
DbConnectionString displayedConnectionsString = null;
DbProvider dbProvider = null;
if (string.IsNullOrEmpty(providerName))
{
foreach (var providerKeyValue in providers)
{
var currentProvider = providerKeyValue.Value;
try
{
displayedConnectionsString = currentProvider.CreateConnectionString(connectionString);
}
catch
{
continue;
}
dbProvider = currentProvider;
break;
}
}
else
{
if (providers.TryGetValue(providerName, out dbProvider))
{
displayedConnectionsString = dbProvider.CreateConnectionString(connectionString);
}
}
_connectionStringTextBox.SetCurrentValue(TextBox.TextProperty, displayedConnectionsString?.ToDisplayString());
SetCurrentValue(DatabaseProviderProperty, dbProvider?.ProviderInvariantName);
_dbProvider = dbProvider?.Info;
}
}
internal static CommerceDbContext Create(CommerceInstanceSettings metadata, ICommerceDbProvider dbProvider)
{
var dbProviderInfo = new DbProviderInfo(metadata.DbProviderInvariantName, metadata.DbProviderManifestToken);
var model = _modelCache.GetOrAdd(new ModelCacheKey(metadata.DbSchema, dbProviderInfo), key =>
{
return(CreateModel(key.Schema, key.DbProviderInfo));
});
var dbProviderFactory = DbConfiguration.DependencyResolver.GetService(typeof(DbProviderFactory), dbProvider.InvariantName) as DbProviderFactory;
var conn = dbProviderFactory.CreateConnection();
conn.ConnectionString = dbProvider.GetConnectionString(metadata);
return(new CommerceDbContext(metadata, conn, model));
}
private DbModel Build(DbProviderManifest providerManifest, DbProviderInfo providerInfo)
{
DebugCheck.NotNull(providerManifest);
DebugCheck.NotNull(providerInfo);
var schemaVersion = _modelBuilderVersion.GetEdmVersion();
var modelBuilderClone = Clone();
var model = new DbModel(
new DbDatabaseMapping()
{
Model = EdmModel.CreateConceptualModel(schemaVersion),
Database = EdmModel.CreateStoreModel(providerInfo, providerManifest, schemaVersion)
},
modelBuilderClone);
model.ConceptualModel.Container.AddAnnotation(XmlConstants.UseClrTypesAnnotationWithPrefix, "true");
_conventionsConfiguration.ApplyModelConfiguration(_modelConfiguration);
_modelConfiguration.NormalizeConfigurations();
MapTypes(model.ConceptualModel);
_modelConfiguration.Configure(model.ConceptualModel);
_conventionsConfiguration.ApplyConceptualModel(model);
model.ConceptualModel.Validate();
model = new DbModel(
model.ConceptualModel.GenerateDatabaseMapping(providerInfo, providerManifest),
modelBuilderClone);
// Run the PluralizingTableNameConvention first so that the new table name is available for configuration
_conventionsConfiguration.ApplyPluralizingTableNameConvention(model);
_modelConfiguration.Configure(model.DatabaseMapping, providerManifest);
_conventionsConfiguration.ApplyStoreModel(model);
_conventionsConfiguration.ApplyMapping(model.DatabaseMapping);
model.StoreModel.Validate();
return(model);
}
static DbCompiledModel CreateModel(string schema, DbProviderInfo dbProviderInfo)
{
var builder = new DbModelBuilder();
if (!String.IsNullOrEmpty(schema))
{
builder.HasDefaultSchema(schema);
}
builder.Conventions.Remove <PluralizingTableNameConvention>();
builder.Conventions.Add <NonPublicPropertyConvention>();
builder.Configurations.AddFromAssembly(Assembly.Load("Kooboo.Commerce.Infrastructure"));
builder.Configurations.AddFromAssembly(Assembly.Load("Kooboo.Commerce"));
return(builder.Build(dbProviderInfo).Compile());
}
private DbCompiledModel GetDbCompiledModel(ShellSettings shellSettings)
{
if (DbCompiledModelCacheDictionary.ContainsKey(shellSettings.Name))
{
return(DbCompiledModelCacheDictionary[shellSettings.Name]);
}
var records = _recordBlueprints.ToArray();
var modelBuilder = new DbModelBuilder();
//设置数据库架构名称。
// modelBuilder.HasDefaultSchema(shellSettings.Name);
//将记录类型添加至DbContext。
foreach (var recordBlueprint in records)
{
Entity(recordBlueprint.Type, modelBuilder);
}
//默认配置信息。
modelBuilder.Types().Configure(config =>
{
var record = records.FirstOrDefault(i => i.Type == config.ClrType);
if (record == null)
{
return;
}
config.ToTable(record.TableName);
});
//应用约定。
modelBuilder.Conventions.Add(GetConventions());
var dataServiceProvider = GetDataServicesProvider(shellSettings);
var connectionString = shellSettings.GetDataConnectionString();
string providerManifestToken;
using (var connection = dataServiceProvider.CreateConnection(connectionString))
providerManifestToken = dataServiceProvider.Instance.GetProviderManifestToken(connection);
var dbProviderInfo = new DbProviderInfo(dataServiceProvider.ProviderInvariantName, providerManifestToken);
var dbModel = modelBuilder.Build(dbProviderInfo);
return(dbModel.Compile());
}
public void UpdateStorageModel_add_errors_if_validation_fails()
{
var edmx = XDocument.Parse(EdmxTemplate);
var storeModel = new EdmModel(DataSpace.SSpace);
var providerInfo = new DbProviderInfo("ProviderInvariantName", "20081");
storeModel.AddItem(
EntityType.Create("entities", "ns", DataSpace.SSpace, new string[0], new EdmMember[0], null));
var errors = new List <EdmSchemaError>();
new EdmxHelper(edmx)
.UpdateStorageModels(storeModel, "myNamespace", providerInfo, errors);
Assert.NotEmpty(errors);
}
/// <summary>
/// 实例化当前数据驱动
/// </summary>
/// <param name="type">驱动类型名</param>
/// <returns>当前的驱动</returns>
public static IDbProvider Instance(ModelType type)
{
DbProviderInfo providerInfo = ModelConfig.GetDbProvider(type);
string typename = providerInfo.Provider;
IDbProvider provider = AppCtx.Cache.RetrieveObject <IDbProvider>(typename);
if (provider == null)
{
string[] s = typename.Split(',');
provider = Utils.CreateInstance <IDbProvider>(s[0], s[1]);
if (provider == null)
{
throw new SystemException("不存在当前数据驱动:" + typename);
}
if (provider is CompositeProvider)
{
CompositeProvider cmp = provider as CompositeProvider;
foreach (NameType item in providerInfo.Items)
{
if (String.Compare("singletable", item.Name, true) == 0 && !GeneralConfigs.GetConfig().EnableSingleTable)
{
continue;
}
IDbProvider subProvider = AppCtx.Cache.RetrieveObject <IDbProvider>(item.Type);
if (subProvider == null)
{
subProvider = Utils.CreateInstance <IDbProvider>(item.Type);
if (subProvider != null)
{
AppCtx.Cache.AddObjectWithFileChange(item.Type, subProvider, ModelConfig.ConfigFilePath, GeneralConfigs.ConfigFile);
}
}
if (subProvider != null)
{
cmp.Add(subProvider);
}
}
}
AppCtx.Cache.AddObjectWithFileChange(typename, provider, ModelConfig.ConfigFilePath, GeneralConfigs.ConfigFile);
}
return(provider);
}
internal DbDatabaseMapping BuildAndValidate(DbProviderInfo providerInfo, bool throwOnError, params Type[] unignoredTypes)
{
IgnoreAll(unignoredTypes);
// Build and clone multiple times to check for idempotency issues.
Build(providerInfo);
var cloned = Clone();
var databaseMapping = cloned.Build(providerInfo).DatabaseMapping;
//databaseMapping.ShellEdmx();
databaseMapping.AssertValid(throwOnError);
return(databaseMapping);
}
public static void Register(string configName, string providerName, string cmdParamNamePrefix, string defaultConnString, Func<string, string> func_3)
{
if (DbProviderInfoContainer.ContainsKey(configName))
{
throw new InvalidOperationException(string.Format("配置项 [{0}] 已经注册过了。", configName));
}
DbProviderInfo dbProviderInfo = new DbProviderInfo
{
dbProviderFactory = GetDbProviderFactory(providerName),
ProviderName = providerName,
CmdParamNamePrefix = cmdParamNamePrefix ?? string.Empty,
DefaultConnString = defaultConnString,
func = func_3
};
DbProviderInfoContainer.Add(configName, dbProviderInfo);
Type type = dbProviderInfo.dbProviderFactory.CreateConnection().GetType();
dbProviderFactoryContainer[type] = dbProviderInfo.dbProviderFactory;
}
internal static EdmModel CreateStoreModel(
EntityContainer entityContainer,
DbProviderInfo providerInfo,
DbProviderManifest providerManifest,
double schemaVersion = 3.0)
{
EdmModel edmModel = new EdmModel(entityContainer, schemaVersion);
if (providerInfo != null)
{
edmModel.ProviderInfo = providerInfo;
}
if (providerManifest != null)
{
edmModel.ProviderManifest = providerManifest;
}
return(edmModel);
}
internal DbModel BuildDynamicUpdateModel(DbProviderInfo providerInfo)
{
DebugCheck.NotNull(providerInfo);
var model = Build(providerInfo);
var entityContainerMapping
= model.DatabaseMapping.EntityContainerMappings.Single();
entityContainerMapping
.EntitySetMappings
.Each(esm => esm.ClearModificationFunctionMappings());
entityContainerMapping
.AssociationSetMappings
.Each(asm => asm.ModificationFunctionMapping = null);
return(model);
}
public virtual string Calculate(DbCompiledModel compiledModel)
{
DbProviderInfo providerInfo = compiledModel.ProviderInfo;
DbModelBuilder dbModelBuilder = compiledModel.CachedModelBuilder.Clone();
EdmMetadataContext.ConfigureEdmMetadata(dbModelBuilder.ModelConfiguration);
EdmModel database = dbModelBuilder.Build(providerInfo).DatabaseMapping.Database;
database.SchemaVersion = 2.0;
StringBuilder stringBuilder = new StringBuilder();
StringBuilder output = stringBuilder;
XmlWriterSettings settings = new XmlWriterSettings()
{
Indent = true
};
using (XmlWriter xmlWriter = XmlWriter.Create(output, settings))
new SsdlSerializer().Serialize(database, providerInfo.ProviderInvariantName, providerInfo.ProviderManifestToken, xmlWriter, true);
return(ModelHashCalculator.ComputeSha256Hash(stringBuilder.ToString()));
}
public static StorageMappingItemCollection GetStorageMappingItemCollection(
this XDocument model,
out DbProviderInfo providerInfo)
{
EdmItemCollection edmCollection = new EdmItemCollection((IEnumerable <XmlReader>) new XmlReader[1]
{
model.Descendants(EdmXNames.Csdl.SchemaNames).Single <XElement>().CreateReader()
});
XElement element = model.Descendants(EdmXNames.Ssdl.SchemaNames).Single <XElement>();
providerInfo = new DbProviderInfo(element.ProviderAttribute(), element.ProviderManifestTokenAttribute());
StoreItemCollection storeCollection = new StoreItemCollection((IEnumerable <XmlReader>) new XmlReader[1]
{
element.CreateReader()
});
return(new StorageMappingItemCollection(edmCollection, storeCollection, (IEnumerable <XmlReader>) new XmlReader[1]
{
new XElement(model.Descendants(EdmXNames.Msl.MappingNames).Single <XElement>()).CreateReader()
}));
}
public static DbModel CreateModel(DbProviderInfo provider)
{
if (_chinookModel == null)
{
var builder = new DbModelBuilder();
builder.Entity <Genre>();
builder.Entity <MediaType>();
builder.Entity <Artist>();
builder.Entity <Album>();
builder.Entity <Track>();
builder.Entity <Employee>();
builder.Entity <Customer>();
builder.Entity <Invoice>();
builder.Entity <InvoiceLine>();
builder.Entity <Playlist>();
builder.Entity <PlaylistTrack>();
_chinookModel = builder.Build(provider);
}
return(_chinookModel);
}
private static DbSpatialServices GetSpatialServices(
IDbDependencyResolver resolver,
DbProviderInfo key,
Func <DbProviderServices> providerServices) // Delegate use to avoid lookup when not needed
{
DebugCheck.NotNull(resolver);
DebugCheck.NotNull(key);
DebugCheck.NotNull(providerServices);
var services = _spatialServices.GetOrAdd(
key,
k =>
resolver.GetService <DbSpatialServices>(k)
?? providerServices().GetSpatialServicesInternal(k.ProviderManifestToken, throwIfNotImplemented: false)
?? resolver.GetService <DbSpatialServices>());
if (services == null)
{
throw new ProviderIncompatibleException(Strings.ProviderDidNotReturnSpatialServices);
}
return(services);
}
private DbModel Build(DbProviderManifest providerManifest, DbProviderInfo providerInfo)
{
DebugCheck.NotNull(providerManifest);
DebugCheck.NotNull(providerInfo);
var model
= new EdmModel(DataSpace.CSpace, _modelBuilderVersion.GetEdmVersion())
{
ProviderInfo = providerInfo
};
_conventionsConfiguration.ApplyModelConfiguration(_modelConfiguration);
_modelConfiguration.NormalizeConfigurations();
MapTypes(model);
_modelConfiguration.Configure(model);
_conventionsConfiguration.ApplyModel(model);
model.Validate();
var databaseMapping = model.GenerateDatabaseMapping(providerManifest);
// Run the PluralizingTableNameConvention first so that the new table name is available for configuration
_conventionsConfiguration.ApplyPluralizingTableNameConvention(databaseMapping.Database);
_modelConfiguration.Configure(databaseMapping, providerManifest);
_conventionsConfiguration.ApplyDatabase(databaseMapping.Database);
_conventionsConfiguration.ApplyMapping(databaseMapping);
databaseMapping.Database.ProviderManifest = providerManifest;
databaseMapping.Database.ProviderInfo = providerInfo;
databaseMapping.Database.Validate();
return(new DbModel(databaseMapping, Clone()));
}
public DbModel Build(DbProviderInfo providerInfo, Uri contextUrl)
{
if (providerInfo == null)
{
throw new ArgumentNullException("providerInfo");
}
if (contextUrl == null)
{
throw new ArgumentNullException("contextUrl");
}
var boundedContextElement = LookupContext(contextUrl);
if (boundedContextElement == null)
{
return(null);
}
var modelBuilder = SetupBuilder(boundedContextElement);
return(modelBuilder.Build(providerInfo));
}
private static DbSpatialServices GetSpatialServices(
IDbDependencyResolver resolver,
DbProviderInfo key,
Func <DbProviderServices> providerServices) // Delegate use to avoid lookup when not needed
{
DebugCheck.NotNull(resolver);
DebugCheck.NotNull(key);
DebugCheck.NotNull(providerServices);
#pragma warning disable 612, 618
var services = _spatialServices.GetOrAdd(
key,
k => resolver.GetService <DbSpatialServices>(k)
?? providerServices().GetSpatialServices(k.ProviderManifestToken)
?? resolver.GetService <DbSpatialServices>());
#pragma warning restore 612, 618
if (services == null)
{
throw new ProviderIncompatibleException(Strings.ProviderDidNotReturnSpatialServices);
}
return(services);
}
