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;
}
