internal StandardCachingStrategyBase(int?maxResults, ICachingProvider cachingProvider)
: base(maxResults, cachingProvider)
{
WriteThroughCachingEnabled = true;
GenerationalCachingEnabled = true;
Partition = null;
}
public L2CacheTest()
{
IServiceCollection services = new ServiceCollection();
services.AddMemoryServices(options =>
{
options.DBConfig.SizeLimit = 100;
options.DBConfig.ExpirationScanFrequency = 10;
});
services.AddRedisServices(options =>
{
options.DBConfig.Password = "******";
options.DBConfig.Endpoints.Add(new Cache.Core.Configurations.ServerEndPoint()
{
Port = 6379,
Host = "r-wz952aaada291544pd.redis.rds.aliyuncs.com"
});
}).AddRedisL2Services()
;
services.AddLogging();
IServiceProvider serviceProvider = services.BuildServiceProvider();
ICachingProviderFactory _factory = serviceProvider.GetService <ICachingProviderFactory>();
_provider = _factory.GetCachingProvider(CachingConstValue.DefaultInMemoryName);
_redis = _factory.GetCachingProvider(CachingConstValue.DefaultRedisName);
_l2CacheProvider = serviceProvider.GetService <IL2CacheProvider>();
_defaultTs = TimeSpan.FromSeconds(600);
}
public EngineHandler(
IOptions <RazorLightOptions> options,
IRazorTemplateCompiler compiler,
ITemplateFactoryProvider factoryProvider,
ICachingProvider cache) : this(options.Value, compiler, factoryProvider, cache)
{
}
public ICompoundKeyCachingStrategy <T> GetCompoundKeyInstance <T>(ICachingProvider cachingProvider) where T : class, new()
{
// load up the factory if it exists and use it
var factory = (IConfigCachingStrategyFactory)Activator.CreateInstance(Factory, this);
return(factory.GetCompoundKeyInstance <T>(cachingProvider));
}
public NotesLoader(IAppUser user, ICachingProvider cachor, IOptions <DomainOptions> opt, /*INotesReader reader,*/ ReaderConnection readerCon)
{
_user = user;
_cachor = cachor;
_opt = opt;
//_reader = reader;
_conReader = readerCon;
}
internal CompoundKeyCachingStrategyCommon(int?maxResults, ICachingProvider cachingProvider)
{
CachePrefix = DefaultRepositoryConventions.CachePrefix;
CachingProvider = cachingProvider;
MaxResults = maxResults;
TypeFullName = typeof(T).FullName ?? typeof(T).Name; // sometimes FullName returns null in certain derived type situations, so I added the check to use the Name property if FullName is null
}
public HomeController(ICachingProviderFactory providerFactory,
IL2CacheProvider l2CacheProvider)
{
_providerFactory = providerFactory;
_l2CacheProvider = l2CacheProvider;
_memoryProvider = _providerFactory.GetCachingProvider(CachingConstValue.DefaultInMemoryName);
_redisProvider = _providerFactory.GetCachingProvider(CachingConstValue.DefaultRedisName);
}
public RedisAndMemoryProvider(ICachingProviderFactory providerFactory
, ILoggerFactory loggerFactory = null)
{
_providerFactory = providerFactory;
_memoryProvider = _providerFactory.GetCachingProvider(CachingConstValue.DefaultInMemoryName);
_redisProvider = _providerFactory.GetCachingProvider(CachingConstValue.DefaultRedisName);
_logger = loggerFactory?.CreateLogger <RedisAndMemoryProvider>();
}
public CachingBehavior(ICachingProvider cachingProvider, ILogger logger)
{
Guard.ArgumentIsNotNull(cachingProvider, "cachingProvider");
Guard.ArgumentIsNotNull(logger, "logger");
_cachingProvider = cachingProvider;
_logger = logger;
}
public AccountController(IMapper mapper, IAccountStore accountStoreService, ICachingProvider cachingProvider, ILogger <AccountController> logger, IOptions <JWTConfig> jwtOptions)
{
_mapper = mapper;
_accountStoreService = accountStoreService;
_caching = cachingProvider.CreateCaching();
_logger = logger;
_jwtConfig = jwtOptions.Value;
}
public Server(ICachingProvider cachingProvider, string ip, int port)
{
_cachingProvider = cachingProvider;
IPAddress localAddr = IPAddress.Parse(ip);
server = new TcpListener(localAddr, port);
server.Start();
StartListener();
}
public PermissionStorageService(
ICachingProvider cacheFactory,
IHttpContextAccessor httpContextAccessor,
ISysResourceService resourceService)
{
_cacheFactory = cacheFactory;
_httpContextAccessor = httpContextAccessor;
_resourceService = resourceService;
}
public AlliterationsProvider(
IAlliterationOptionsFactory alliterationOptionsFactory,
IRandomNumberGenerator randomNumberGenerator,
ICachingProvider cachingProvider)
{
this.alliterationOptionsFactory = alliterationOptionsFactory;
this.randomNumberGenerator = randomNumberGenerator;
this.cachingProvider = cachingProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="BlogPostTasks"/> class.
/// </summary>
/// <param name="blogPostSpecificationFactory">
/// The blog post specification factory.
/// </param>
/// <param name="blogPostRepository">
/// The blog post repository.
/// </param>
/// <param name="cachingProvider">
/// The caching provider.
/// </param>
public BlogPostTasks(
IBlogPostSpecificationFactory blogPostSpecificationFactory,
IBlogPostRepository blogPostRepository,
ICachingProvider cachingProvider)
{
this.blogPostSpecificationFactory = blogPostSpecificationFactory;
this.blogPostRepository = blogPostRepository;
this.cachingProvider = cachingProvider;
}
/// <summary>
/// Returns the cached result if exists, or will execute the query and add the result in cache.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="slidingExpiration"></param>
/// <returns></returns>
public static IEnumerable <T> FromCache <T>(this IQueryable <T> query, TimeSpan expiration)
{
string key = query.GetKey();
ICachingProvider provider = ProviderManager.Provider;
provider.Get(out IEnumerable <T> result, key, expiration, query);
return(result);
}
public CachedSettingProvider(ISettingProvider settingProvider, ICachingProvider cachingProvider, TimeSpan defaultAbsoluteExpiration)
{
Guard.ArgumentIsNotNull(settingProvider, "settingProvider");
Guard.ArgumentIsNotNull(cachingProvider, "cachingProvider");
_settingProvider = settingProvider;
_cachingProvider = cachingProvider;
_defaultAbsoluteExpiration = defaultAbsoluteExpiration;
}
public CacheRepositoryConfiguration(string name, string prefix, ICachingProvider cachingProviderInstance, string cachingStrategy = null, string cachingProvider = null)
: base(name)
{
Prefix = prefix;
CachingStrategy = cachingStrategy;
CachingProvider = cachingProvider;
CachingProviderInstance = cachingProviderInstance;
Factory = typeof(CacheConfigRepositoryFactory);
}
public Toolbox(IOptions <DomainOptions> options, ICachingProvider cachor, IUnitOfWork <CPDbContext> reader, IIndex <DomainSetter, IDomainSetter> domainSetter, IMapper mapper, IEventSender sender)
{
Options = options;
Cachor = cachor;
Reader = reader;
DomainSetter = domainSetter;
Mapper = mapper;
Sender = sender;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceValidatorBase" /> class.
/// </summary>
/// <param name="unitOfWork">The unit of work.</param>
/// <param name="authenticationProvider">The authentication provider.</param>
/// <param name="messageProvider">The message provider.</param>
/// <param name="cachingProvider">The caching provider.</param>
/// <param name="serializationProvider">The serialization provider.</param>
public ServiceValidatorBase(
IUnitOfWork unitOfWork,
IAuthenticationProvider authenticationProvider,
IMessageProvider messageProvider,
ICachingProvider cachingProvider,
ISerializationProvider serializationProvider)
: base(unitOfWork, authenticationProvider, messageProvider, cachingProvider, serializationProvider)
{
}
public CachedServiceClient(IServiceClient serviceClient, ICachingProvider cachingProvider, TimeSpan defaultAbsoluteExpiration)
{
Guard.ArgumentIsNotNull(serviceClient, "serviceClient");
Guard.ArgumentIsNotNull(cachingProvider, "cachingProvider");
_serviceClient = serviceClient;
_cachingProvider = cachingProvider;
_defaultAbsoluteExpiration = defaultAbsoluteExpiration;
}
/// <summary>
/// Initializes a new instance of the <see cref="UserController"/> class.
/// </summary>
/// <param name="userSaveDetailsMapper">
/// The user save details mapper.
/// </param>
/// <param name="userTasks">
/// The user tasks.
/// </param>
/// <param name="cachingProvider">
/// The caching provider.
/// </param>
/// <param name="userSignOnDetailsMapper">
/// The user Sign On Details Mapper.
/// </param>
public UserController(
IUserSaveDetailsMapper userSaveDetailsMapper,
IUserTasks userTasks,
ICachingProvider cachingProvider,
IUserSignOnDetailsMapper userSignOnDetailsMapper)
{
this.userSaveDetailsMapper = userSaveDetailsMapper;
this.userTasks = userTasks;
this.cachingProvider = cachingProvider;
this.userSignOnDetailsMapper = userSignOnDetailsMapper;
}
public virtual RazorLightEngineBuilder UseCachingProvider(ICachingProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
cachingProvider = provider;
return(this);
}
public RazorLightEngine(
RazorLightOptions options,
IRazorTemplateCompiler templateCompiler,
ITemplateFactoryProvider factoryProvider,
ICachingProvider cachingProvider)
{
Options = options ?? throw new ArgumentNullException(nameof(options));
TemplateFactoryProvider = factoryProvider ?? throw new ArgumentNullException(nameof(factoryProvider));
TemplateCompiler = templateCompiler ?? throw new ArgumentNullException(nameof(templateCompiler));
TemplateCache = cachingProvider;
}
public Reddit(IListingFilter listingFilter, UserState userState, IActionDeferralSink deferalSink, ICaptchaProvider captchaProvider, string appId = null, string appSecret = null, string redirectUrl = null, ICachingProvider cacheProvider = null, INetworkLayer networkLayer = null)
{
_cacheProvider = cacheProvider;
_networkLayer = networkLayer ?? new NetworkLayer(userState, appId, appSecret, redirectUrl);
_listingFilter = listingFilter;
_userState = userState ?? new UserState();
_deferalSink = deferalSink;
_captchaProvider = captchaProvider;
_appId = appId;
_appSecret = appSecret;
_redirectUrl = redirectUrl;
}
public EngineHandler(
RazorLightOptions options,
IRazorTemplateCompiler compiler,
ITemplateFactoryProvider factoryProvider,
ICachingProvider cache)
{
Options = options ?? throw new ArgumentNullException(nameof(options));
Compiler = compiler ?? throw new ArgumentNullException(nameof(compiler));
FactoryProvider = factoryProvider ?? throw new ArgumentNullException(nameof(factoryProvider));
Cache = cache;
}
public override ICompoundKeyCachingStrategy <T> GetCompoundKeyInstance <T>(ICachingProvider cachingProvider)
{
if (!Int32.TryParse(CachingStrategyConfiguration["timeout"], out int timeout))
{
throw new ConfigurationErrorsException("The timeout attribute is required in order to use the TimeoutCachingStrategy via the configuration file.");
}
return(new TimeoutCompoundKeyCachingStrategy <T>(timeout, cachingProvider)
{
MaxResults = CachingStrategyConfiguration.MaxResults
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceBase" /> class.
/// </summary>
/// <param name="unitOfWork">The unit of work.</param>
/// <param name="authenticationProvider">The authentication provider.</param>
/// <param name="messageProvider">The message provider.</param>
/// <param name="cachingProvider">The caching provider.</param>
/// <param name="serializationProvider">The serialization provider.</param>
public ServiceBase(
IUnitOfWork unitOfWork,
IAuthenticationProvider authenticationProvider,
IMessageProvider messageProvider,
ICachingProvider cachingProvider,
ISerializationProvider serializationProvider)
{
this.UnitOfWork = unitOfWork;
this.AuthenticationProvider = authenticationProvider;
this.MessageProvider = messageProvider;
this.CachingProvider = cachingProvider;
this.SerializationProvider = serializationProvider;
}
public CachingInterceptor(ICachingProvider cachingProvider, IDateTimeProvider dateTimeProvider)
{
if (cachingProvider == null)
{
throw new ArgumentNullException(nameof(cachingProvider));
}
if (dateTimeProvider == null)
{
throw new ArgumentNullException(nameof(dateTimeProvider));
}
this.cachingProvider = cachingProvider;
this.dateTimeProvider = dateTimeProvider;
}
public async Task GetSetTest()
{
var c = ContainerHelper.Builder();
ICachingProvider _cp = c.Resolve <ICachingProvider>();
var val = await _cp.Get("a", async() =>
{
await Task.CompletedTask;
return("aab");
});
Assert.AreEqual(val, "aab");
}
protected override IController GetControllerInstance(System.Web.Routing.RequestContext requestContext, Type controllerType)
{
if (controllerType == typeof(BlogController))
{
PersonalWebsiteContext context = new PersonalWebsiteContext();
_provider = _provider ?? new CachingProvider();
BlogRepository repo = new BlogRepository(context, _provider);
return new BlogController(repo);
}
else if (controllerType == typeof(ErrorController))
{
return new ErrorController(new SqlLoggingRepository());
}
else
return base.GetControllerInstance(requestContext, controllerType);
}
private static ICachingProvider GetCurrentProvider()
{
const string message = @"Unable to perform caching. No cache provider has been specified.";
if (_currentProvider == null)
{
throw new InvalidOperationException(message);
}
ICachingProvider cachingProvider = _currentProvider();
if (cachingProvider == null)
{
throw new InvalidOperationException(message);
}
return(cachingProvider);
}
/// <summary>
/// 设置缓存供应器。
/// </summary>
/// <param name="provider">供应器。</param>
/// <param name="level">缓存层级。</param>
/// <returns></returns>
public static void RegisterProvider(ICachingProvider provider, Level level = Level.First)
{
if (provider is null)
{
throw new ArgumentNullException(nameof(provider));
}
switch (level)
{
case Level.First:
case Level.Second:
case Level.Third:
CacheProvider[level] = provider;
break;
default:
throw new NotSupportedException();
}
}
public RazorLightEngine(
RazorLightOptions options,
ITemplateFactoryProvider factoryProvider,
ICachingProvider cachingProvider)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (factoryProvider == null)
{
throw new ArgumentNullException(nameof(factoryProvider));
}
Options = options;
templateFactoryProvider = factoryProvider;
cache = cachingProvider;
}
public MultiServerCachePrefixManager(ICachingProvider cachingProvider, string key = "#Repos/GlobalCacheCounter")
{
_cachingProvider = cachingProvider;
_key = key;
}
public WebOutputCacheAttrribute()
{
this.cachingProvider = ServiceLocator.Current.GetInstance<ICachingProvider>();
}
public TagTasks(ICachingProvider cachingProvider)
{
this.cachingProvider = cachingProvider;
}
//Our composition Root
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var emailConfig = ConfigurationManager.GetSection("EmailLogger") as EmailLogConfiguration; //Ensure Web.Config is correctly configured.
if (emailConfig == null)
throw new ConfigurationErrorsException("Email Logger was not configured correctly");
ILogger emailLoggingProvider = new EmailLogger(emailConfig);
SqlLoggingRepository sqlLogRepo = new SqlLoggingRepository();
ILogger sqlLoggingProvider = new SqlLogger(sqlLogRepo);
Global.Logger = new LoggingService(sqlLoggingProvider, emailLoggingProvider);
string userName = ConfigurationManager.AppSettings["AdminDefaultUserName"];
if (Membership.FindUsersByName(userName).Count == 0)
{
string password = ConfigurationManager.AppSettings["AdminDefaultPassword"];
string email = ConfigurationManager.AppSettings["AdminDefaultEmail"];
MembershipCreateStatus createStatus;
Membership.CreateUser(userName, password, email, passwordQuestion: null, passwordAnswer: null, isApproved: true, providerUserKey: null, status: out createStatus);
if (createStatus != MembershipCreateStatus.Success)
throw new MembershipCreateUserException(createStatus.ToString());
}
var unhandledErrorAttr = new LoggingHandleErrorAttribute(Global.Logger);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters, new object[] { unhandledErrorAttr });
Database.SetInitializer<PersonalWebsiteContext>(new ContextInitializer());
_cache = new CachingProvider();
var controllerFactory = new PersonalWebsiteControllerFactory(_cache);
ControllerBuilder.Current.SetControllerFactory(controllerFactory);
}
public PersonalWebsiteControllerFactory(ICachingProvider provider)
{
_provider = provider;
}
/// <summary>
/// Initializes a new instance of the <see cref="PostController"/> class.
/// </summary>
/// <param name="blogTasks">
/// The blog tasks.
/// </param>
/// <param name="blogPostSaveDetailsMapper">
/// The blog post save details mapper.
/// </param>
/// <param name="blogPostPageViewModelMapper">
/// The blog post page view model mapper.
/// </param>
/// <param name="identityService">
/// The identity Service.
/// </param>
/// <param name="blogPostCommentSaveDetailsMapper">
/// The blog Post Comment Save Details Mapper.
/// </param>
/// <param name="cachingProvider">
/// The caching provider.
/// </param>
public PostController(
IBlogTasks blogTasks,
IBlogPostSaveDetailsMapper blogPostSaveDetailsMapper,
IBlogPostPageViewModelMapper blogPostPageViewModelMapper,
IIdentityService identityService,
IBlogPostCommentSaveDetailsMapper blogPostCommentSaveDetailsMapper, ICachingProvider cachingProvider)
{
this.blogTasks = blogTasks;
this.cachingProvider = cachingProvider;
this.blogPostSaveDetailsMapper = blogPostSaveDetailsMapper;
this.blogPostPageViewModelMapper = blogPostPageViewModelMapper;
this.identityService = identityService;
this.blogPostCommentSaveDetailsMapper = blogPostCommentSaveDetailsMapper;
}
/// <summary>
/// Create a new readonly view (and copy) of the given configuration.
/// </summary>
/// <param name="config">the configuration to copy.</param>
public ReadOnlyTemplateServiceConfiguration(ITemplateServiceConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
_allowMissingPropertiesOnDynamic = config.AllowMissingPropertiesOnDynamic;
_activator = config.Activator;
if (_activator == null)
{
throw new ArgumentNullException("config", "the configured Activator cannot be null!");
}
_baseTemplateType = config.BaseTemplateType;
// Check if the baseTemplateType is valid.
if (_baseTemplateType != null && (!typeof(ITemplate).IsAssignableFrom(_baseTemplateType) || typeof(ITemplate) == _baseTemplateType))
{
throw new ArgumentOutOfRangeException("config", "the configured BaseTemplateType must implement ITemplate!");
}
_cachingProvider = config.CachingProvider;
if (_cachingProvider == null)
{
throw new ArgumentNullException("config", "the configured CachingProvider cannot be null!");
}
#if !RAZOR4
#pragma warning disable 0618 // Backwards Compat.
_codeInspectors = config.CodeInspectors;
if (_codeInspectors == null)
{
throw new ArgumentNullException("config", "the configured CodeInspectos cannot be null!");
}
_codeInspectors = new List<ICodeInspector>(_codeInspectors);
#pragma warning restore 0618 // Backwards Compat.
#endif
_compilerServiceFactory = config.CompilerServiceFactory;
if (_compilerServiceFactory == null)
{
throw new ArgumentNullException("config", "the configured CompilerServiceFactory cannot be null!");
}
_debug = config.Debug;
_disableTempFileLocking = config.DisableTempFileLocking;
_encodedStringFactory = config.EncodedStringFactory;
if (_encodedStringFactory == null)
{
throw new ArgumentNullException("config", "the configured EncodedStringFactory cannot be null!");
}
_language = config.Language;
_namespaces = config.Namespaces;
if (_namespaces == null)
{
throw new ArgumentNullException("config", "the configured Namespaces cannot be null!");
}
_namespaces = new HashSet<string>(_namespaces);
_referenceResolver = config.ReferenceResolver;
if (_referenceResolver == null)
{
throw new ArgumentNullException("config", "the configured ReferenceResolver cannot be null!");
}
#pragma warning disable 0618 // Backwards Compat.
_resolver = config.Resolver;
_templateManager = config.TemplateManager;
if (_templateManager == null)
{
if (_resolver != null)
{
_templateManager = new Xml.WrapperTemplateManager(_resolver);
}
else
{
throw new ArgumentNullException("config", "the configured TemplateManager and Resolver cannot be null!");
}
}
#pragma warning restore 0618 // Backwards Compat.
}
///<Summary>
/// Either use a Unit of Work, or manually ensure all Repos share the same context.
///</Summary>
public BlogRepository(PersonalWebsiteContext context, ICachingProvider cache)
{
_context = context;
_cache = cache;
}
/// <summary>
/// Initializes a new instance of the <see cref="BlogController"/> class.
/// </summary>
/// <param name="blogTasks">
/// The blog tasks.
/// </param>
/// <param name="blogPostTasks">
/// The blog Post Tasks.
/// </param>
/// <param name="blogSaveDetailsMappper">
/// The blog Save Details Mappper.
/// </param>
/// <param name="blogPageViewModelMapper">
/// The blog Page View Model Mapper.
/// </param>
/// <param name="blogPostListPageViewModelMapper">
/// The blog Post List Page View Model Mapper.
/// </param>
/// <param name="blogPostArchivePageViewModelMapper">
/// The blog Post Archive Page View Model Mapper.
/// </param>
/// <param name="identityService">
/// The identity Service.
/// </param>
/// <param name="cachingProvider">
/// The caching provider.
/// </param>
/// <param name="blogUserPageViewModelMapper">
/// The blog User Page View Model Mapper.
/// </param>
public BlogController(
IBlogTasks blogTasks,
IBlogPostTasks blogPostTasks,
IBlogSaveDetailsMappper blogSaveDetailsMappper,
IBlogPageViewModelMapper blogPageViewModelMapper,
IBlogPostListPageViewModelMapper blogPostListPageViewModelMapper,
IBlogPostArchivePageViewModelMapper blogPostArchivePageViewModelMapper,
IIdentityService identityService,
ICachingProvider cachingProvider,
IBlogUserPageViewModelMapper blogUserPageViewModelMapper)
{
this.blogTasks = blogTasks;
this.blogUserPageViewModelMapper = blogUserPageViewModelMapper;
this.identityService = identityService;
this.cachingProvider = cachingProvider;
this.blogPostTasks = blogPostTasks;
this.blogSaveDetailsMappper = blogSaveDetailsMappper;
this.blogPageViewModelMapper = blogPageViewModelMapper;
this.blogPostListPageViewModelMapper = blogPostListPageViewModelMapper;
this.blogPostArchivePageViewModelMapper = blogPostArchivePageViewModelMapper;
}
private static void LoadTagsIntoCache(IReferenceDataRepository referenceDataRepository, ICachingProvider cachingProvider)
{
var rootTag = referenceDataRepository.FindAll<Tag>().First(x => x.Parent == null);
cachingProvider.Insert(rootTag);
}
/// <summary>
/// Initializes a new instance of the <see cref="BlogTasks"/> class.
/// </summary>
/// <param name="blogRepository">
/// The blog repository.
/// </param>
/// <param name="blogSpecificationFactory">
/// The blog specifications factory.
/// </param>
/// <param name="blogMapper">
/// The blog Mapper.
/// </param>
/// <param name="blogPostMapper">
/// The blog Post Mapper.
/// </param>
/// <param name="identityService">
/// The identity Service.
/// </param>
/// <param name="blogPostCommentMapper">
/// The blog Post Comment Mapper.
/// </param>
/// <param name="cachingProvider">
/// The caching provider.
/// </param>
public BlogTasks(
IBlogRepository blogRepository,
IBlogSpecificationFactory blogSpecificationFactory,
IBlogMapper blogMapper,
IBlogPostMapper blogPostMapper,
IIdentityService identityService,
IBlogPostCommentMapper blogPostCommentMapper,
ICachingProvider cachingProvider)
{
this.blogRepository = blogRepository;
this.blogSpecificationFactory = blogSpecificationFactory;
this.blogMapper = blogMapper;
this.blogPostMapper = blogPostMapper;
this.identityService = identityService;
this.blogPostCommentMapper = blogPostCommentMapper;
this.cachingProvider = cachingProvider;
}
