/// <summary>
/// Register mapping
/// </summary>
/// <param name="config">Config</param>
protected virtual void RegisterMapperConfiguration(VConfig config)
{
//dependencies
var typeFinder = new WebAppTypeFinder();
//register mapper configurations provided by other assemblies
var mcTypes = typeFinder.FindClassesOfType <IMapperConfiguration>();
var mcInstances = new List <IMapperConfiguration>();
foreach (var mcType in mcTypes)
{
mcInstances.Add((IMapperConfiguration)Activator.CreateInstance(mcType));
}
//sort
mcInstances = mcInstances.AsQueryable().OrderBy(t => t.Order).ToList();
//get configurations
var configurationActions = new List <Action <IMapperConfigurationExpression> >();
foreach (var mc in mcInstances)
{
configurationActions.Add(mc.GetConfiguration());
}
//register
AutoMapperConfiguration.Init(configurationActions);
}
/// <summary>
/// Register dependencies
/// </summary>
/// <param name="config">Config</param>
protected virtual void RegisterDependencies(VConfig config)
{
var builder = new ContainerBuilder();
//dependencies
var typeFinder = new WebAppTypeFinder();
builder.RegisterInstance(config).As <VConfig>().SingleInstance();
builder.RegisterInstance(this).As <IEngine>().SingleInstance();
builder.RegisterInstance(typeFinder).As <ITypeFinder>().SingleInstance();
//register dependencies provided by other assemblies
var drTypes = typeFinder.FindClassesOfType <IDependencyRegistrar>();
var drInstances = new List <IDependencyRegistrar>();
foreach (var drType in drTypes)
{
drInstances.Add((IDependencyRegistrar)Activator.CreateInstance(drType));
}
//sort
drInstances = drInstances.AsQueryable().OrderBy(t => t.Order).ToList();
foreach (var dependencyRegistrar in drInstances)
{
dependencyRegistrar.Register(builder, typeFinder, config);
}
var container = builder.Build();
this._containerManager = new ContainerManager(container);
//set dependency resolver
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
public static void SyncCollection <TSource, TDestination>(this IEnumerable <TSource> sourceCollection, ICollection <TDestination> targetCollection, bool useStrict = true)
{
var config = new VConfig
{
UseStrict = useStrict
};
SyncCollection(sourceCollection, targetCollection, config);
}
public static void MapTo <TSource, TDestination>(this TSource parent, TDestination target, bool useStrict = true)
{
var config = new VConfig
{
UseStrict = useStrict
};
MapTo(parent, target, config);
}
public AESFile()
{
InitializeComponent();
usageCheck = new DataUsageCheck();
config = new VConfig();
usage = usageCheck.initData();
DataContextChanged += AESFile_DataContextChanged;
SaltTitle.MouseLeftButtonDown += new MouseButtonEventHandler(SaltTitle_MouseLeftButtonDown);
}
/// <summary>
/// Initialize components and plugins in the nop environment.
/// </summary>
/// <param name="config">Config</param>
public void Initialize(VConfig config)
{
//register dependencies
RegisterDependencies(config);
//register mapper configurations
RegisterMapperConfiguration(config);
//startup tasks
if (!config.IgnoreStartupTasks)
{
RunStartupTasks();
}
}
public static Pipeline Create(VConfig config, IChannel input, IChannel output, List <IFilter> inputFiters,
List <IFilter> outputFilters, ILogger logger = null)
{
if (config is VrtuConfig)
{
return(Create((VrtuConfig)config, input, output, inputFiters, outputFilters, logger));
}
if (config is ModuleConfig)
{
return(Create((ModuleConfig)config, input, output, inputFiters, outputFilters, logger));
}
throw new InvalidCastException("VConfig invalid type.");
}
public Dictionary <String, String> CacheAttributes(Type source, Type target, VConfig configSettings)
{
try
{
if (_cacheMetadata.Any())
{
return(_cacheMetadata);
}
var sourceMembers = source.GetMembers().Where(member => member.MemberType == MemberTypes.Field || member.MemberType == MemberTypes.Property).ToList();
var targetMembers = target.GetMembers().Where(member => member.MemberType == MemberTypes.Field || member.MemberType == MemberTypes.Property).ToList();
CacheType(sourceMembers, targetMembers);
}
catch (Exception)
{
if (configSettings.UseStrict)
{
throw;
}
}
return(_cacheMetadata);
}
public IPipelineBuilder AddConfig(VConfig config)
{
this.config = config;
return(this);
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public virtual void Register(ContainerBuilder builder, ITypeFinder typeFinder, VConfig config)
{
//HTTP context and other related stuff
builder.Register(c =>
(new HttpContextWrapper(HttpContext.Current) as HttpContextBase))
.As <HttpContextBase>()
.InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Request)
.As <HttpRequestBase>()
.InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Response)
.As <HttpResponseBase>()
.InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Server)
.As <HttpServerUtilityBase>()
.InstancePerLifetimeScope();
builder.Register(c => c.Resolve <HttpContextBase>().Session)
.As <HttpSessionStateBase>()
.InstancePerLifetimeScope();
//controllers
builder.RegisterControllers(typeFinder.GetAssemblies().ToArray());
//data layer
var dataSettingsManager = new DataSettingsManager();
var dataProviderSettings = dataSettingsManager.LoadSettings();
builder.Register(c => dataSettingsManager.LoadSettings()).As <DataSettings>();
builder.Register(x => new EfDataProviderManager(x.Resolve <DataSettings>())).As <BaseDataProviderManager>().InstancePerDependency();
builder.Register(x => x.Resolve <BaseDataProviderManager>().LoadDataProvider()).As <IDataProvider>().InstancePerDependency();
if (dataProviderSettings != null && dataProviderSettings.IsValid())
{
var efDataProviderManager = new EfDataProviderManager(dataSettingsManager.LoadSettings());
var dataProvider = efDataProviderManager.LoadDataProvider();
dataProvider.InitConnectionFactory();
builder.Register <IDbContext>(c => new VObjectContext(dataProviderSettings.DataConnectionString)).InstancePerLifetimeScope();
}
else
{
builder.Register <IDbContext>(c => new VObjectContext(dataSettingsManager.LoadSettings().DataConnectionString)).InstancePerLifetimeScope();
}
//repository
builder.RegisterGeneric(typeof(EfRepository <>)).As(typeof(IRepository <>)).InstancePerLifetimeScope();
#region services
builder.RegisterType <PostService>().As <IPostService>().InstancePerLifetimeScope();
#endregion
}
public static void FillType(this Object target, Object source, Type sourceType, Type targetType, Dictionary <String, String> propertyNames, VConfig config)
{
try
{
foreach (var prop in propertyNames)
{
try
{
var value = GetPropValue(source, sourceType, prop.Key);
SetPropValue(target, targetType, prop.Value, value);
}
catch (Exception)
{
if (config.UseStrict)
{
throw;
}
}
}
}
catch (Exception)
{
if (config.UseStrict)
{
throw;
}
}
}
public static void SyncCollection <TSource, TDestination>(this IEnumerable <TSource> sourceCollection, ICollection <TDestination> targetCollection, VConfig settings)
{
Type sourceType = typeof(TSource);
Type targetType = typeof(TDestination);
var cache = new Api();
var mappingFields = cache.CacheAttributes(sourceType, targetType, settings);
foreach (var item in sourceCollection)
{
var instance = Activator.CreateInstance <TDestination>();
instance.FillType(item, sourceType, targetType, mappingFields, settings);
targetCollection.Add(instance);
}
}
public static void MapTo <TSource, TDestination>(this TSource parent, TDestination target, VConfig config)
{
try
{
Type sourceType = typeof(TSource);
Type targetType = typeof(TDestination);
var cache = new Api();
var mappingFields = cache.CacheAttributes(sourceType, targetType, config);
target.FillType(parent, sourceType, targetType, mappingFields, config);
}
catch (Exception ex)
{
if (config.UseStrict)
{
throw new Exception(String.Format("Source and Destination are incompactable : " + ex.Message));
}
}
}
