public static FilePathCombiner GenerateAccessorFilePath(DbContextAccessorBase accessor,
                                                                string extension, string basePath = null, Type designTimeType = null)
        {
            accessor.NotNull(nameof(accessor));
            extension.NotEmpty(nameof(extension));

            var filePath = new FilePathCombiner(GetAccessorFileName(), basePath);

            filePath.CreateDirectory();

            return(filePath);

            // GetAccessorFileName
            string GetAccessorFileName()
            {
                var connector = DataSettings.Preference.AccessorIsolateableStringConnector;

                var builder = new StringBuilder();

                AppendAccessorIsolateableString(accessor, builder, connector, designTimeType);

                builder.Append(extension);

                return(builder.ToString());
            }
        }
Beispiel #2
0
        public CaptchaService(DrawingBuilderDependency dependency, ILoggerFactory loggerFactory)
            : base(dependency?.Options, loggerFactory)
        {
            Dependency = dependency;

            _fontFilePath = Options.Captcha.Font.FilePath
                            .ChangeBasePathIfEmpty(dependency.ResourceDirectory);
        }
        public SecurityTokenKeyRing(IMemoryCache memoryCache,
                                    IClockService clock, CoreBuilderDependency dependency)
        {
            _memoryCache = memoryCache.NotNull(nameof(memoryCache));
            _clock       = clock.NotNull(nameof(clock));

            _keysFilePath = CoreSettings.Preference.SecurityTokenKeyRingFilePath
                            .ChangeBasePathIfEmpty(dependency?.TokensDirectory);
        }
Beispiel #4
0
        public WatermarkService(DrawingBuilderDependency dependency, ILoggerFactory loggerFactory)
            : base(dependency?.Options, loggerFactory)
        {
            Dependency = dependency;

            _watermarkImagePath = Options.Watermark.ImagePath
                                  .ChangeBasePathIfEmpty(dependency.ResourceDirectory);

            _fontFilePath = Options.Watermark.Font.FilePath
                            .ChangeBasePathIfEmpty(dependency.ResourceDirectory);
        }
        /// <summary>
        /// 生成访问器(持久化)键名(借助访问器文件路径组合器支持访问器、设计时、连接字符串、租户隔离)。
        /// </summary>
        /// <param name="invokeTypeName">给定的调用类型名称。</param>
        /// <param name="accessorFilePath">给定的访问器(持久化)文件路径组合器。</param>
        /// <returns>返回字符串。</returns>
        public static string GenerateAccessorKey(string invokeTypeName,
                                                 FilePathCombiner accessorFilePath)
        {
            invokeTypeName.NotNull(nameof(invokeTypeName));
            accessorFilePath.NotNull(nameof(accessorFilePath));

            var sb = new StringBuilder();

            sb.Append(invokeTypeName);
            sb.Append(';');

            // 访问器文件路径组合器已作有效隔离
            sb.Append(accessorFilePath);

            return(sb.ToString());
        }
Beispiel #6
0
        public static FilePathCombiner CompileInFile(FilePathCombiner assemblyPath, IEnumerable <MetadataReference> references,
                                                     params string[] sourceCodes)
        {
            assemblyPath.NotNull(nameof(assemblyPath));

            var syntaxTrees    = sourceCodes.Select(s => SyntaxFactory.ParseSyntaxTree(s));
            var compileOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
            var compilation    = CSharpCompilation.Create(assemblyPath.FileName, syntaxTrees, references, compileOptions);

            using (var stream = File.OpenWrite(assemblyPath))
            {
                var result = compilation.Emit(stream);
                if (!result.Success)
                {
                    throw new InvalidOperationException($"Build failed. Diagnostics: {string.Join(Environment.NewLine, result.Diagnostics)}");
                }
            }

            return(assemblyPath);
        }
 /// <summary>
 /// 生成访问器(持久化)键名(借助访问器文件路径组合器支持访问器、设计时、连接字符串、租户隔离)。
 /// </summary>
 /// <param name="invokeType">给定的调用类型。</param>
 /// <param name="accessorFilePath">给定的访问器(持久化)文件路径组合器。</param>
 /// <returns>返回字符串。</returns>
 public static string GenerateAccessorKey(Type invokeType,
                                          FilePathCombiner accessorFilePath)
 => GenerateAccessorKey(invokeType.GetDisplayName(true), accessorFilePath);
Beispiel #8
0
 private static string GetCacheKey(FilePathCombiner filePath)
 => DbContextAccessorHelper.GenerateAccessorKey(nameof(MigrationCommandExecutionValidator), filePath);
Beispiel #9
0
        /// <summary>
        /// 从文件中反编译为程序集。
        /// </summary>
        /// <param name="assemblyPath">给定的 <see cref="FilePathCombiner"/>。</param>
        /// <returns>返回 <see cref="Assembly"/>。</returns>
        public static Assembly DecompileFromFile(FilePathCombiner assemblyPath)
        {
            var buffer = File.ReadAllBytes(assemblyPath);

            return(Assembly.Load(buffer));
        }
Beispiel #10
0
        public static FilePathCombiner CompileInFile(DbContextAccessorBase accessor,
                                                     IModel model, DataBuilderOptions options, FilePathCombiner filePath)
        {
            accessor.NotNull(nameof(accessor));
            model.NotNull(nameof(model));

            var accessorType = accessor.GetType();
            var typeName     = GenerateTypeName(accessorType);

            var generator  = accessor.GetService <IMigrationsCodeGenerator>();
            var sourceCode = generator.GenerateSnapshot(typeName.Namespace, accessorType,
                                                        typeName.Name, model);

            var references = GetMetadataReferences(options, accessorType);

            return(CSharpCompiler.CompileInFile(filePath, references, sourceCode));
        }