public override IEntityContextConfiguration GetConfiguration() { var configuration = new EntityContextConfiguration(); var connection = new EntityContextConnection {Directory = Directory}; configuration.Connection = connection; return configuration; }
static CommandParameter() { configuration = EntityContextConfiguration.GetConfiguration <TEntityContext>(); KeyProperty = CommandParameterKeyProperty <TEntityContext, TEntity> .Default; TrackableProperties = CommandParameterTrackableProperties <TEntityContext, TEntity> .Default; AcceptableProperties = CommandParameterAcceptableProperties <TEntityContext, TEntity> .Default; }
#pragma warning disable 1591 // Xml Comments public override void Initialize(IContainer container) { if (EntityContextConfiguration != null) { EntityContextConfiguration.BindEntityContextTo <TaskEntity>(container); } base.Initialize(container); }
#pragma warning disable 1591 // Xml Comments public override void Initialize(IContainer container) { if (EntityContextConfiguration == null) { EntityContextConfiguration = new NullEntityContextConfiguration(); } EntityContextConfiguration.BindDefaultEntityContext(container); base.Initialize(container); }
public override IEntityContextConfiguration GetConfiguration() { var configuration = new EntityContextConfiguration(); var connection = new EntityContextConnection(_typeDiscoverer); connection.FluentConfiguration.Database( MsSqlConfiguration.MsSql2008.ConnectionString(ConnectionString)); configuration.Connection = connection; connection.Configure(); return configuration; }
/// <summary> /// Configure the default storage mechanism to use MongoDB /// </summary> /// <param name="storage"><see cref="IHaveStorage"/> to configure</param> /// <param name="configureCallback">Callback to configure more details for the connections</param> /// <returns>Chained <see cref="IConfigure"/></returns> public static IConfigure UsingMongoDB(this IHaveStorage storage, Action <EntityContextConfiguration> configureCallback) { var entityContextConfiguration = new EntityContextConfiguration(); configureCallback(entityContextConfiguration); var connection = new EntityContextConnection(entityContextConfiguration); entityContextConfiguration.Connection = connection; storage.EntityContextConfiguration = entityContextConfiguration; return(Configure.Instance); }
/// <summary> /// Use EntityFramework as <see cref="IHaveStorage">storage</see> /// </summary> /// <param name="storage"><see cref="IHaveStorage"/> to configure</param> /// <param name="connectionConfiguration">Callback for configuration the connection</param> /// <returns></returns> public static IConfigure UsingEntityFramework(this IHaveStorage storage, Action <EntityContextConfiguration> connectionConfiguration) { var configuration = new EntityContextConfiguration(); connectionConfiguration(configuration); var connection = new EntityContextConnection(configuration); configuration.Connection = connection; storage.EntityContextConfiguration = configuration; return(Configure.Instance); }
public override void Initialize(IContainer container) { container.Bind <IUncommittedEventStreamCoordinator>(UncommittedEventStreamCoordinatorType); container.Bind <IEventStore>(EventStoreType, BindingLifecycle.Singleton); container.Bind <IEventSubscriptions>(EventSubscriptionsType, BindingLifecycle.Singleton); if (EntityContextConfiguration != null) { EntityContextConfiguration.BindEntityContextTo <IEvent>(container); EntityContextConfiguration.BindEntityContextTo <EventSubscription>(container); base.Initialize(container); } }
static EnterpriseContext() { EntityContextConfiguration <EnterpriseContext> config = EntityContextConfiguration.Configure <EnterpriseContext>(); config.Entities.Add <Product>(); config.Entities.Add <Address>(); config.Entities.Add <Shipment>(); config.Entities.Add <Customer>(); config.Entities.Add <Order>(); config.Entities.Add <OrderDetail>(); config.EntityKeys.Add <Product>(e => e.ID); config.EntityKeys.Add <Address>(e => e.ID); config.EntityKeys.Add <Shipment>(e => e.ID); config.EntityKeys.Add <Customer>(e => e.ID); config.EntityKeys.Add <Order>(e => e.ID); config.EntityKeys.Add <OrderDetail>(e => e.ID); config.EntityTrackings.Except <Product>(e => e.RV); config.EntityTrackings.Except <Address>(e => e.RV); config.EntityTrackings.Except <Shipment>(e => e.RV); config.EntityTrackings.Except <Customer>(e => e.RV); config.EntityTrackings.Except <Order>(e => e.RV); config.EntityTrackings.Except <OrderDetail>(e => e.RV); config.EntityTrackings.Except <Product>(e => e.YearlyIncome); config.EntityRelations.OneToOne.Add <Customer, Address>(e => e.CustomerID, e => e.Customer, e => e.Address); config.EntityRelations.OneToMany.Add <Customer, Customer>(e => e.FirstPartnerID, e => e.FirstPartner, e => e.FirstPartners); config.EntityRelations.OneToMany.Add <Customer, Customer>(e => e.SecondPartnerID, e => e.SecondPartner, e => e.SecondPartners); config.EntityRelations.OneToMany.Add <Customer, Order>(e => e.CustomerID, e => e.Customer, e => e.Orders); config.EntityRelations.OneToOne.Add <Order, Shipment>(e => e.OrderID, e => e.Order, e => e.Shipment); config.EntityRelations.OneToMany.Add <Order, OrderDetail>(e => e.OrderID, e => e.Order, e => e.OrderDetails); config.EntityRelations.OneToMany.Add <Product, OrderDetail>(e => e.ProductID, e => e.Product); config.EntitySets.Add(ctx => ctx.Products); config.EntitySets.Add(ctx => ctx.Addresses); config.EntitySets.Add(ctx => ctx.Shipments); config.EntitySets.Add(ctx => ctx.Customers); config.EntitySets.Add(ctx => ctx.Orders); config.EntitySets.Add(ctx => ctx.OrderDetails); config.EntityProperties.Add <Customer>(e => e.FirstName, "FName"); config.EntityProperties.Add <Customer>(e => e.LastName, "LName"); config.EntityProperties.Add <Customer>(e => e.NationalIdentityNumber, "NIN"); config.Build(); }
public override void Initialize(IContainer container) { if (LibrarianType != null) { container.Bind <ISagaLibrarian>(LibrarianType); } if (EntityContextConfiguration != null) { EntityContextConfiguration.BindEntityContextTo <SagaHolder>(container); EntityContextConfiguration.BindEntityContextTo <ChapterHolder>(container); } base.Initialize(container); }
/// <inheritdoc/> public override void Initialize(IContainer container) { container.Bind <ICanSendCommittedEventStream>(CommittedEventStreamSender.CommittedEventStreamSender, BindingLifecycle.Singleton); container.Bind <ICanReceiveCommittedEventStream>(CommittedEventStreamReceiver.CommittedEventStreamReceiver, BindingLifecycle.Singleton); container.Bind <IEventStore>(EventStore.EventStore, BindingLifecycle.Singleton); container.Bind <IEventSourceVersions>(EventSourceVersions.EventSourceVersions, BindingLifecycle.Singleton); container.Bind <IEventSequenceNumbers>(EventSequenceNumbers.EventSequenceNumbers, BindingLifecycle.Singleton); container.Bind <IEventProcessorLog>(EventProcessorLog, BindingLifecycle.Singleton); container.Bind <IEventProcessorStates>(EventProcessorStates.EventProcessorStates, BindingLifecycle.Singleton); if (EntityContextConfiguration != null) { EntityContextConfiguration.BindEntityContextTo <IEvent>(container); base.Initialize(container); } }
static EntityDatabaseWriterInsert() { EntityContextConfiguration <TEntityContext> configuration = EntityContextConfiguration.GetConfiguration <TEntityContext>(); Type typeEntity = typeof(TEntity); PropertyInfo key = configuration.EntityKeys.GetPropEntityKey(typeEntity); #region Generate CallBackData Setter #region Expression Tree #if ET { Type typeData = EntityProxy <TEntity> .DataType; Type typeProxyData = typeof(EntityProxy <,>).MakeGenericType(new[] { typeEntity, typeData }); Type typeEntitySet = typeof(EntitySet <>).MakeGenericType(typeEntity); MethodInfo propEntitySetGetMthd = typeEntity.GetProperty("EntitySet", typeEntitySet).GetGetMethod(true); MethodInfo mthdOnPropChng = typeEntity.GetMethod("OnPropertyChanged", BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(string) }, null); MethodInfo propDataGetMthd = typeEntity.GetProperty("Data", BindingFlags.NonPublic | BindingFlags.Instance).GetGetMethod(true); FieldInfo fldItem = typeProxyData.GetField("item"); ParameterExpression dr = Expression.Parameter(typeof(SqlDataReader), "dr"); ParameterExpression e = Expression.Parameter(typeof(TEntity), "e"); Expression[] expressions = new Expression[2]; //key expressions expressions[0] = Expression.Assign(Expression.Field(Expression.Field(Expression.TypeAs(Expression.Call(e, propDataGetMthd), typeProxyData), fldItem), typeData.GetField(key.Name)), Expression.Call(key.GetDataReaderGetValueMethod(), dr, Expression.Constant(0))); expressions[1] = Expression.Call(e, mthdOnPropChng, Expression.Constant(key.Name)); SetCallBackData = Expression.Lambda <Action <SqlDataReader, TEntity> >(Expression.Block(expressions), dr, e).Compile(); } #endif #endregion Expression Tree #region IL #if IL { } #endif #endregion IL #endregion Generate CallBackData Setter }
/// <summary> /// Configures <see cref="IHaveStorage">storage</see> to use a DocumentDB /// </summary> /// <param name="storage"><see cref="IHaveStorage">Storage</see> to configure</param> /// <param name="callback">Chained callback for configuring the specifics</param> /// <returns>Chained <see cref="IConfigure"/> for fluent configuration</returns> public static IConfigure UsingDocumentDB(this IHaveStorage storage, Action <EntityContextConfiguration> callback) { var configuration = new EntityContextConfiguration(); callback(configuration); var collectionStrategy = new MultipleEntitiesInOneCollection(); var connection = new EntityContextConnection(configuration, collectionStrategy); configuration.Connection = connection; storage.EntityContextConfiguration = configuration; Configure.Instance.Container.Bind <ICollectionStrategy>(collectionStrategy); return(Configure.Instance); }
/// <summary> /// Configures <see cref="IHaveStorage">storage</see> to use a simple files system /// </summary> /// <param name="storage"><see cref="IHaveStorage">Storage</see> to configure</param> /// <param name="path">Path to store files</param> /// <returns>Chained <see cref="IConfigure"/> for fluent configuration</returns> public static IConfigure UsingFiles(this IHaveStorage storage, string path) { if (!Path.IsPathRooted(path)) { path = Path.Combine(Directory.GetCurrentDirectory(), path); } var configuration = new EntityContextConfiguration { Path = path }; configuration.Connection = new EntityContextConnection(configuration); storage.EntityContextConfiguration = configuration; return(Configure.Instance); }
public static IConfigure UsingRavenDB(this IHaveStorage storage, Action <EntityContextConfiguration> configureCallback = null) { var entityContextConfiguration = new EntityContextConfiguration { IdPropertyRegister = new NullIdPropertyRegister() }; if (configureCallback != null) { configureCallback(entityContextConfiguration); } var connection = new EntityContextConnection(entityContextConfiguration); entityContextConfiguration.Connection = connection; storage.EntityContextConfiguration = entityContextConfiguration; return(Configure.Instance); }
/// <summary> /// Configure the authorization key to use /// </summary> /// <param name="configuration"><see cref="EntityContextConfiguration"/> to configure</param> /// <param name="authorizationKey">Authorization key to use</param> /// <returns>Chained <see cref="EntityContextConfiguration"/> to configure</returns> public static EntityContextConfiguration UsingAuthorizationKey(this EntityContextConfiguration configuration, string authorizationKey) { configuration.AuthorizationKey = authorizationKey; return(configuration); }
/// <summary> /// Configure the default database by its databaseId /// </summary> /// <param name="configuration"><see cref="EntityContextConfiguration"/> to configure</param> /// <param name="databaseId">Database id to connect to</param> /// <returns>Chained <see cref="EntityContextConfiguration"/> to configure</returns> public static EntityContextConfiguration WithDefaultDatabase(this EntityContextConfiguration configuration, string databaseId) { configuration.DatabaseId = databaseId; return(configuration); }
/// <summary> /// Configure the Url endpoint for the database server /// </summary> /// <param name="configuration"><see cref="EntityContextConfiguration"/> to configure</param> /// <param name="url"></param> /// <returns>Chained <see cref="EntityContextConfiguration"/> to configure</returns> public static EntityContextConfiguration WithUrl(this EntityContextConfiguration configuration, string url) { configuration.Url = url; return(configuration); }
public static EntityContextConfiguration WithDefaultDatabase(this EntityContextConfiguration configuration, string defaultDatabase) { configuration.DefaultDatabase = defaultDatabase; return(configuration); }
/// <summary> /// Configure with a given connection string /// </summary> /// <param name="configuration"><see cref="EntityContextConfiguration"/> to configure</param> /// <param name="connectionString">Connection string to use</param> /// <returns>Chained <see cref="EntityContextConfiguration"/> to configure</returns> public static EntityContextConfiguration WithConnectionString(this EntityContextConfiguration configuration, string connectionString) { configuration.ConnectionString = connectionString; return(configuration); }
internal Configuration(EntityContextConfiguration <TEntityContext> EntityContextConfiguration) { this.EntityContextConfiguration = EntityContextConfiguration; }
static EntityDatabaseWriterInsert() { EntityContextConfiguration <TEntityContext> configuration = EntityContextConfiguration.GetConfiguration <TEntityContext>(); Type typeEntity = typeof(TEntity); Type typeEntityCallBack = typeof(TEntityCallBack); PropertyInfo key = configuration.EntityKeys.GetPropEntityKey(typeEntity); PropertyInfo[] entityCallBackProperties = typeEntityCallBack.GetEntityAcceptableDataProperties().ToArray(); #region Generate CallBackData Setter #region Expression Tree #if ET { int counter = 0; int index = 0; int resize = 0; Type typeData = EntityProxy <TEntity> .DataType; Type typeProxyData = typeof(EntityProxy <,>).MakeGenericType(new[] { typeEntity, typeData }); Type typeEntitySet = typeof(EntitySet <>).MakeGenericType(typeEntity); MethodInfo propEntitySetGetMthd = typeEntity.GetProperty("EntitySet", typeEntitySet).GetGetMethod(true); MethodInfo mthdOnPropChng = typeEntity.GetMethod("OnPropertyChanged", BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(string) }, null); MethodInfo propDataGetMthd = typeEntity.GetProperty("Data", BindingFlags.NonPublic | BindingFlags.Instance).GetGetMethod(true); FieldInfo fldItem = typeProxyData.GetField("item"); ParameterExpression dr = Expression.Parameter(typeof(SqlDataReader), "dr"); ParameterExpression e = Expression.Parameter(typeof(TEntity), "e"); Expression[] expressions = new Expression[(entityCallBackProperties.Length + 1) * 2]; //key expressions expressions[counter++] = Expression.Assign(Expression.Field(Expression.Field(Expression.TypeAs(Expression.Call(e, propDataGetMthd), typeProxyData), fldItem), typeData.GetField(key.Name)), Expression.Call(key.GetDataReaderGetValueMethod(), dr, Expression.Constant(index++))); expressions[counter++] = Expression.Call(e, mthdOnPropChng, Expression.Constant(key.Name)); foreach (PropertyInfo propCallBack in entityCallBackProperties) { PropertyInfo propEntity = typeEntity.GetProperty(propCallBack.Name); EntityRelation entityRelation = configuration.EntityRelations.GetEntityRelation(propEntity); if (entityRelation == null) { expressions[counter++] = Expression.Assign(Expression.Field(Expression.Field(Expression.TypeAs(Expression.Call(e, propDataGetMthd), typeProxyData), fldItem), typeData.GetField(propCallBack.Name)), Expression.Call(propCallBack.GetDataReaderGetValueMethod(), dr, Expression.Constant(index++))); expressions[counter++] = Expression.Call(e, mthdOnPropChng, Expression.Constant(propCallBack.Name)); } else { Type typeEditedEntity = typeof(EditedEntity <,>).MakeGenericType(typeEntity, propCallBack.PropertyType); Type typeEditedProperty = typeof(EditedProperty <>).MakeGenericType(propCallBack.PropertyType); ConstructorInfo ctrEdtdProp = typeEditedProperty.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(PropertyInfo), propCallBack.PropertyType, propCallBack.PropertyType }, null); ConstructorInfo ctrEdtdEnty = typeEditedEntity.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeEditedProperty, typeof(TrakMode) }, null); Expression expNewEdtdProp = Expression.New(ctrEdtdProp, new Expression[] { Expression.Constant(propEntity), Expression.Field(Expression.Field(Expression.TypeAs(Expression.Call(e, propDataGetMthd), typeProxyData), fldItem), typeData.GetField(propCallBack.Name)), Expression.Call(propCallBack.GetDataReaderGetValueMethod(), dr, Expression.Constant(index++)) }); Expression expNewEdtdEnty = Expression.New(ctrEdtdEnty, new Expression[] { expNewEdtdProp, Expression.Constant(TrakMode.None) }); MethodInfo mthdCallBack = typeof(EntitySet <TEntity>).GetMethod("CallBack", BindingFlags.NonPublic | BindingFlags.Instance).MakeGenericMethod(propCallBack.PropertyType); expressions[counter++] = Expression.Call(Expression.Call(e, propEntitySetGetMthd), mthdCallBack, new[] { e, expNewEdtdEnty }); resize++; } } if (resize > 0) { Array.Resize(ref expressions, expressions.Length - resize); } SetCallBackData = Expression.Lambda <Action <SqlDataReader, TEntity> >(Expression.Block(expressions), dr, e).Compile(); } #endif #endregion Expression Tree #region IL #if IL { } #endif #endregion IL #endregion Generate CallBackData Setter }
/// <summary> /// Enable SSL for th connection to the MongoDB server /// </summary> /// <param name="configuration">Fluent <see cref="EntityContextConfiguration"/></param> /// <returns>Chained <see cref="EntityContextConfiguration"/></returns> public static EntityContextConfiguration WithSSL(this EntityContextConfiguration configuration) { configuration.UseSSL = true; return(configuration); }
public static IConfigure UsingNHibernate(this IHaveStorage storage, EntityContextConfiguration entityContextConfiguration, Func <ISessionFactory> getSessionFactory) { storage.EntityContextConfiguration = entityContextConfiguration; Configure.Instance.Container.Bind <IConnection>(new ReadConnection(getSessionFactory)); return(Configure.Instance); }
public static EntityContextConfiguration WithCredentials(this EntityContextConfiguration configuration, ICredentials credentials) { configuration.Credentials = credentials; return(configuration); }
public static IConfigure UsingNHibernate(this IHaveStorage storage, EntityContextConfiguration entityContextConfiguration, Func<ISessionFactory> getSessionFactory) { storage.EntityContextConfiguration = entityContextConfiguration; Configure.Instance.Container.Bind<IConnection>(new ReadConnection(getSessionFactory)); return Configure.Instance; }