# базовый пакет [README-zh.md](README-zh.md)
PM> Install-Package ShardingCore
# драйвер для SQL Server
PM> Install-Package Microsoft.EntityFrameworkCore.SqlServer
# драйвер для MySQL
#PM> Install-Package Pomelo.EntityFrameworkCore.MySql
# использование других драйверов базы данных, если EF Core поддерживает

    /// Таблица заказов
    /// </summary>
    public class Order
    {
        /// <summary>
        /// Идентификатор заказа
        /// </summary>
        public string Id { get; set; }
        /// <summary>
        /// Идентификатор плательщика
        /// </summary>
        public string Payer { get; set; }
        /// <summary>
        /// Сумма платежа в центах
        /// </summary>
        public long Money { get; set; }
        /// <summary>
        /// Регион
        /// </summary>
        public string Area { get; set; }
        /// <summary>
        /// Статус заказа
        /// </summary>
        public OrderStatusEnum OrderStatus { get; set; }
        /// <summary>
        /// Время создания
        /// </summary>
        public DateTime CreationTime { get; set; }
    }
    public enum OrderStatusEnum
    {
        Неоплачен = 1,
        Оплачивается = 2,
        Оплачен = 3,
        ОплатаНесуспешна = 4
    }

    {
        public MyDbContext(DbContextOptions<MyDbContext> options) : base(options)
        {
        }

        ```markdown
        ```csharp
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Entity<Order>(entity =>
            {
                entity.HasKey(o => o.Id);
                entity.Property(o => o.Id).IsRequired().IsUnicode(false).HasMaxLength(50);
                entity.Property(o => o.Payer).IsRequired().IsUnicode(false).HasMaxLength(50);
                entity.Property(o => o.Area).IsRequired().IsUnicode(false).HasMaxLength(50);
                entity.Property(o => o.OrderStatus).HasConversion<int>();
                // действительно имя таблицы Order_202101, Order_202102, Order_202103 и т.д.
                entity.ToTable(nameof(Order));
            });
        }
        /// <summary>
        /// пустая реализация, если используется разбиение на таблицы
        /// </summary>
        public IRouteTail RouteTail { get; set; }
        ```
        ```

### Шаг 4: Создание маршрута для отображения имени таблицы, используемой для запроса данных (Order)

```csharp
// Конструктор маршрута поддерживает внедрение зависимостей, что означает, что его жизненный цикл — это `Singleton`

    public class OrderVirtualTableRoute : AbstractSimpleShardingMonthKeyDateTimeVirtualTableRoute<Order>
    {
        // private readonly IServiceProvider _serviceProvider;
```        //public OrderVirtualTableRoute(IServiceProvider serviceProvider)
        //{
            //_serviceProvider = serviceProvider;
        //}
        /// <summary>
        /// фиксированное значение, не используйте DateTime.Now, так как при перезапуске приложения это значение изменится.
        /// </summary>
        /// <returns></returns>
        public override DateTime GetBeginTime()
        {
            return new DateTime(2021, 1, 1);
        }
        /// <summary>
        /// настройка свойства разбиения.
        /// </summary>
        /// <param name="builder"></param>```markdown
        public void ConfigureServices(IServiceCollection services)
        {

            //конфигурация шардинга
            services.AddShardingDbContext<MyDbContext>()
                .UseRouteConfig(op =>
                {
                    op.AddShardingTableRoute<OrderVirtualTableRoute>();
                }).UseConfig(op =>
                {
                    op.UseShardingQuery((connStr, builder) =>
                    {
                        //connStr — это входной параметр делегата
                        builder.UseSqlServer(connStr);
                    });
                    op.UseShardingTransaction((connection, builder) =>
                    {
                        //connection — это входной параметр делегата
                        builder.UseSqlServer(connection);
                    });
                    //используйте строку подключения к базе данных
                    op.AddDefaultDataSource(Guid.NewGuid().ToString("n"),
                        "Data Source=localhost;Initial Catalog=EFCoreShardingTableDB;Integrated Security=True;");
                }).AddShardingCore();
        }
```        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            // Не обязательно, включает проверку отсутствующих таблиц и автоматическое создание
            app.ApplicationServices.UseAutoTryCompensateTable();
            // другие настройки....
        }

[Route("api/[controller]")]
public class ValuesController : Controller
{
        private readonly MyDbContext _myDbContext;
```        public ValuesController(MyDbContext myDbContext)
        {
            _myDbContext = myDbContext;
        }

        [HttpGet]
        public async Task<IActionResult> Get()
        {
            
            //_myDbContext.Add(order);
            //_myDbContext.Update(order);
            //_myDbContext.Remove(order);
            //_myDbContext.SaveChanges();
            var order = await _myDbContext.Set<Order>().FirstOrDefaultAsync(o => o.Id == "2");
            return Ok(order);
        }
}

<PackageReference Include="ShardingCore" Version="5.LastVersion" />
или
<PackageReference Include="ShardingCore" Version="3.LastVersion" />
или
<PackageReference Include="ShardingCore" Version="2.LastVersion" />

    public class SysUserMod
    {
        /// <summary>
        /// Идентификатор пользователя для шардинга
        /// </summary>
        public string Id { get; set; }
        /// <summary>
        /// Имя пользователя
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// Возраст пользователя
        /// </summary>
        public int Age { get; set; }
    }
    

    public class SysUserModVirtualTableRoute : AbstractSimpleShardingModKeyStringVirtualRoute<SysUserMod>
    {
        //2 хвост длиной:00,01,02......99
        //3 хэш % 3: [0,1,2]
        public SysUserModVirtualTableRoute() : base(2, 3)
        {
        }
        public override void Configure(EntityMetadataTableBuilder<SysUserMod> builder)
        {
            builder.ShardingProperty(o => o.Id);
        }
    }

  //DefaultShardingDbContext — это фактический исполняемый dbcontext
    public class DefaultShardingDbContext : AbstractShardingDbContext, IShardingTableDbContext
    {
        public DefaultShardingDbContext(DbContextOptions<DefaultShardingDbContext> options) : base(options)
        {
        }
    }
``````c#

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.ApplyConfiguration(new SysUserModMap());
        }
        public IRouteTail RouteTail { get; set; }

    }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            //если вы хотите использовать операции без шардинга
            //services.AddDbContext<DefaultTableDbContext>(o => o.UseSqlServer("Data Source=localhost;Initial Catalog=ShardingCoreDB;Integrated Security=True"));

    //добавить поддержку шардинг контекста для жизненного цикла
                
        services.AddShardingDbContext<DefaultShardingDbContext>(
                   (conStr, builder) => builder.UseSqlServer(conStr)
                )
                .Begin(o =>
                {
                    o.CreateShardingTableOnStart = true; //создать шардинг таблицу
                    o.EnsureCreatedWithOutShardingTable = true; //создать источник данных без шардинг таблицы
                })  .AddShardingTransaction((connection, builder) =>
                    builder.UseSqlServer(connection))
                .AddDefaultDataSource("ds0", "Data Source=localhost;Initial Catalog=ShardingCoreDB1;Integrated Security=True;")
                .AddShardingTableRoute(o =>
                {
                    o.AddShardingTableRoute<SysUserModVirtualTableRoute>();
                }).End();

            var shardingBootstrapper = app.ApplicationServices.GetRequiredService<IShardingBootstrapper>();
            shardingBootstrapper.Start();

    
        private readonly DefaultShardingDbContext _defaultShardingDbContext;
``````markdown
## Распределение баз данных

```c#
```Для примера возьмем модуль пользователя. Рекомендуется использовать [fluent api](https://docs.microsoft.com/en-us/ef/core/modeling/) для конфигурации entity.
Объекты баз данных `IShardingDataSource` должны наследовать этот интерфейс.
Поле распределения баз данных `ShardingDataSourceKey` должно использовать этот атрибут.
```c#
    public class SysUserMod
    {
        /// <summary>
        /// Идентификатор пользователя для распределения по базам данных
        /// </summary>
        public string Id { get; set; }
        /// <summary>
        /// Имя пользователя
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// Возраст пользователя
        /// </summary>
        public int Age { get; set; }
    }
    

``````markdown
Если вы используете разделение баз данных, вам не потребуется интерфейс `IShardingTableDbContext`.
Для создания контекста баз данных с разделением таблиц необходимо наследовать от `AbstractShardingDbContext`.


```c#
// DefaultShardingDbContext является фактическим контекстом баз данных
public class DefaultShardingDbContext : AbstractShardingDbContext
{
    public DefaultShardingDbContext(DbContextOptions<DefaultShardingDbContext> options) : base(options)
    {
    }
}
``````c#
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    // добавляем поддержку ShardingDbContext для жизненного цикла
    services.AddShardingDbContext<DefaultShardingDbContext>(
        (conStr, builder) => builder.UseSqlServer(conStr)
    ).Begin(o =>
    {
        o.CreateShardingTableOnStart = true;
        o.EnsureCreatedWithOutShardingTable = true;
    })
    .AddShardingTransaction((connection, builder) =>
        builder.UseSqlServer(connection))
    .AddDefaultDataSource("ds0", "Data Source=localhost;Initial Catalog=ShardingCoreDBxx0;Integrated Security=True;")
    .AddShardingDataSource(sp =>
    {
        return new Dictionary<string, string>()
        {
            {"ds1", "Data Source=localhost;Initial Catalog=ShardingCoreDBxx1;Integrated Security=True;"},
            {"ds2", "Data Source=localhost;Initial Catalog=ShardingCoreDBxx2;Integrated Security=True;"},
        };
    }).AddShardingDataSourceRoute(o =>
    {
        o.AddShardingDatabaseRoute<SysUserModVirtualDataSourceRoute>();
    }).End();

var shardingBootstrapper = app.ApplicationServices.GetRequiredService<IShardingBootstrapper>();
shardingBootstrapper.Start();

private readonly DefaultShardingDbContext _defaultShardingDbContext;
``````csharp
        public async Task Insert_1000()
        {
            if (!_defaultShardingDbContext.Set<SysUserMod>().Any())
            {
                var ids = Enumerable.Range(1, 1000);
                var userMods = new List<SysUserMod>();
                foreach (var id in ids)
                {
                    userMods.Add(new SysUserMod()
                    {
                        Id = id.ToString(),
                        Age = id,
                        Name = $"имя_{id}",
                        AgeGroup = Math.Abs(id % 10)
                    });
                }
        ``````markdown
                    _defaultShardingDbContext.AddRange(userMods);                   await _defaultShardingDbContext.SaveChangesAsync();
                }
        }
        public async Task ToList_All()
        {
            
            var mods = await _defaultShardingDbContext.Set<SysUserMod>().ToListAsync();
            Assert.Equal(1000, mods.Count);

            var modOrders1 = await _defaultShardingDbContext.Set<SysUserMod>().OrderBy(o => o.Age).ToListAsync();
            int ascAge = 1;
            foreach (var sysUserMod in modOrders1)
            {
                Assert.Equal(ascAge, sysUserMod.Age);
                ascAge++;
            }

            var modOrders2 = await _defaultShardingDbContext.Set<SysUserMod>().OrderByDescending(o => o.Age).ToListAsync();
            int descAge = 1000;
            foreach (var sysUserMod in modOrders2)
            {
                Assert.Equal(descAge, sysUserMod.Age);
                descAge--;
            }
        }

Разделение по базам данных предоставляет маршрут по умолчанию, а разделение по таблицам требует реализации самостоятельно. Конкретная реализация может быть найдена в разделении по базам данных. Абстрактный | Правила маршрутизации | хвост | индекс
--- |--- |--- |---
AbstractSimpleShardingModKeyIntVirtualTableRoute | по модулю | 0, 1, 2... | `=, contains`
AbstractSimpleShardingModKeyStringVirtualTableRoute | по модулю | 0, 1, 2... | `=, contains`
AbstractSimpleShardingDayKeyDateTimeVirtualTableRoute | по времени | yyyyMMdd | `>, >=, <, <=, =, contains`
AbstractSimpleShardingDayKeyLongVirtualTableRoute | по времени (timestamp) | yyyyMMdd | `>, >=, <, <=, =, contains`
AbstractSimpleShardingWeekKeyDateTimeVirtualTableRoute | по времени | yyyyMMdd_dd | `>, >=, <, <=, =, contains`
AbstractSimpleShardingWeekKeyLongVirtualTableRoute | по времени (timestamp) | yyyyMMdd_dd | `>, >=, <, <=, =, contains`
AbstractSimpleShardingMonthKeyDateTimeVirtualTableRoute | по времени | yyyyMM | `>, >=, <, <=, =, contains`
AbstractSimpleShardingMonthKeyLongVirtualTableRoute | по времени (timestamp) | yyyyMM | `>, >=, <, <=, =, contains`
AbstractSimpleShardingYearKeyDateTimeVirtualTableRoute | по времени | yyyy | `>, >=, <, <=, =, contains`
AbstractSimpleShardingYearKeyLongVirtualTableRoute | по времени (timestamp) | yyyy | `>, >=, <, <=, =, contains`

Примечание: `contains` указывает на `o => ids.contains(o.shardingkey)`

Примечание: Использование по умолчанию правила маршрутизации по времени разделения таблиц будет требовать переопределения метода `GetBeginTime`. Этот метод должен использовать статическое значение, например: `new DateTime(2021, 1, 1)`, динамическое значение, например `DateTime.Now`, использовать нельзя, так как при каждом перезапуске будет вызван этот метод, что приведет к несоответствиям.# Продвинутый

## code-first
В настоящее время `sharding-core` поддерживает code-first, подробная реализация можно посмотреть в [Migrations](https://github.com/xuejmnet/sharding-core/tree/main/samples/Sample.Migrations/readme.md)

## Автоматическое отслеживание
По умолчанию `shardingcore` не поддерживает автоматическое отслеживание, и его не рекомендуется использовать. Если вам это необходимо, `shardingcore` по умолчанию предоставляет функцию автоматического отслеживания.
Важно отметить следующие моменты:
1. В настоящее время поддерживается только объект с одним первичным ключом.
2. `shardingcore` поддерживает только модели `dbcontext`, анонимные типы запросов не поддерживаются.
3. Одиночные запросы `shardingcore` выполняются напрямую в базе данных, а не в кэше. Если результат запроса уже находится в кэше, он будет возвращен из кэша, а не из базы данных.
4. Операции, такие как `ToList`, выполняют запрос к базе данных и возвращают результат. Если результат уже отслеживается, он будет возвращен из кэша.
5. Поддерживается `first`, `firstordefault`, `last`, `lastordefault`, `single`, `singleordefault`.
Как включить:
```c#
services.AddShardingDbContext<DefaultShardingDbContext>(.......)
            .Begin(o => {
                    o.CreateShardingTableOnStart = true;
                    o.EnsureCreatedWithOutShardingTable = true;
                    //поддержка автоматического отслеживания asnotracking astracking QueryTrackingBehavior.TrackAll
                    o.AutoTrackEntity = true; 
                })

ctor inject IShardingRouteManager shardingRouteManager
``````markdown
## Автоматическое создание таблиц
[Ссылка](https://github.com/xuejmnet/sharding-core/tree/main/samples/Samples.AutoByDate.SqlServer)

## Транзакции
1. По умолчанию поддерживается транзакция с помощью `SaveChangesAsync`
```c#
await _defaultShardingDbContext.SaveChangesAsync();

using (var tran = _defaultTableDbContext.DataBase.BeginTransaction())
{
    ........
    _defaultTableDbContext.SaveChanges();
    tran.Commit();
}

var list = new List<SysUserMod>();
var dbContexts = _defaultTableDbContext.BulkShardingEnumerable(list);
``````csharp
foreach (var dataSourceMap in dbContexts)
{
    foreach (var tailMap in dataSourceMap.Value)
    {
        tailMap.Key.BulkInsert(tailMap.Value.ToList());
        //tailMap.Key.BulkDelete(tailMap.Value.ToList());
        //tailMap.Key.BulkUpdate(tailMap.Value.ToList());
    }
}
_defaultTableDbContext.SaveChanges();
//или
var dbContexts = _defaultTableDbContext.BulkShardingEnumerable(list);
using (var tran = _defaultTableDbContext.Database.BeginTransaction())
{
    foreach (var dataSourceMap in dbContexts)
    {
        foreach (var tailMap in dataSourceMap.Value)
        {
            tailMap.Key.BulkInsert(tailMap.Value.ToList());
            //tailMap.Key.BulkDelete(tailMap.Value.ToList());
            //tailMap.Key.BulkUpdate(tailMap.Value.ToList());
        }
    }
    _defaultTableDbContext.SaveChanges();
    tran.Commit();
}

Данная фреймворк поддерживает разделение на один основной и несколько дополнительных узлов для чтения и записи `AddReadWriteSeparation`. Поддерживает два типа стратегий разделения на чтение и запись: циклический `Loop` и случайный `Random`. Однако, при использовании нескольких соединений для чтения и записи могут возникнуть проблемы с несоответствием данных (например, при пагинации это происходит в два этапа: сначала получение количества записей, затем получение списка записей), что может привести к проблемам с количеством данных на последних страницах.

Для решения этой проблемы фреймворк реализовал стратегию получения соединений для чтения `ReadConnStringGetStrategyEnum.LatestEveryTime`, которая означает, что каждое соединение будет новым (что может привести к вышеупомянутым проблемам), и `ReadConnStringGetStrategyEnum.LatestFirstTime`, которая означает, что соединение будет получено один раз на уровне `dbcontext` (что не приведет к проблемам на уровне `dbcontext`).Также из-за различных проблем с сетью, связанных с разделением на чтение и запись, новые записи могут не быть доступны. Поэтому система по умолчанию добавляет флаг использования разделения на чтение и запись на уровне `dbcontext`. Если `false`, то по умолчанию используется строка для записи для чтения `_defaultTableDbContext.ReadWriteSeparation=false` или используются два готовых метода.
```c#
// Переключение на только чтение, только запись и только конфигурация для чтения A и B источников данных
_virtualDbContext.ReadWriteSeparationReadOnly();
_virtualDbContext.ReadWriteSeparationWriteOnly();

services.AddShardingDbContext<DefaultShardingDbContext>(
    (conStr, builder) => builder.UseSqlServer(conStr).UseLoggerFactory(efLogger)
).Begin(o =>
{
    o.CreateShardingTableOnStart = true;
    o.EnsureCreatedWithOutShardingTable = true;
})
.AddShardingTransaction((connection, builder) =>
    builder.UseSqlServer(connection).UseLoggerFactory(efLogger))
.AddDefaultDataSource("ds0",
    "Data Source=localhost;Initial Catalog=ShardingCoreDB1;Integrated Security=True;"
)
.AddShardingTableRoute(o =>
{
    o.AddShardingTableRoute<SysUserModVirtualTableRoute>();
})
.AddReadWriteSeparation(o =>
{
    return new Dictionary<string, ISet<string>>()
    {
        {
            "ds0", new HashSet<string>(){
            "Data Source=localhost;Initial Catalog=ShardingCoreDBReadOnly1;Integrated Security=True;",
            "Data Source=localhost;Initial Catalog=ShardingCoreDBReadOnly2;Integrated Security=True;"}
        }
    };
}, ReadStrategyEnum.Loop, defaultEnable: true)
.End();

         public override IPaginationConfiguration<SysUserSalary> CreatePaginationConfiguration()
         {
             return new SysUserSalaryPaginationConfiguration();
         }

var shardingPageResultAsync = await _defaultTableDbContext.Set<SysUserMod>().OrderBy(o => o.Age).ToShardingPageAsync(pageIndex, pageSize);
```### Внимание: если вы сортируете по времени, рекомендуется включить сортировку по времени независимо от направления. Если вы используете модульное или пользовательское распределение по таблицам, рекомендуется использовать Id для прямой сортировки и добавить обратную сортировку для оптимизации производительности. Если entity поддерживает распределение по таблицам и базам данных, и оба маршрута поддерживают сортировку по одному и тому же полю, приоритет будет следующим: сначала распределение по базам данных, затем по таблицам.

## Кэширование выражений
Кэширование выражений может быть включено через маршрутизацию для кэширования выражений для отдельного tail. Поддерживает операторы =, >, >=, <, <=, equal.

```c#
    public class OrderCreateTimeVirtualTableRoute : AbstractSimpleShardingMonthKeyDateTimeVirtualTableRoute<Order>
    {
        // включение кэширования выражений
        public override bool EnableRouteParseCompileCache => true;
    }

    public virtual Func<string, bool> CachingCompile(Expression<Func<string, bool>> parseWhere)
    {
        if (EnableRouteParseCompileCache)
        {
            var doCachingCompile = DoCachingCompile(parseWhere);
            if (doCachingCompile != null)
                return doCachingCompile;
            doCachingCompile = CustomerCachingCompile(parseWhere);
            if (doCachingCompile != null)
```                    return doCachingCompile;
             }
             return parseWhere.Compile();
         }
         /// <summary>
         /// Системное по умолчанию постоянное кэширование одного выражения
         /// </summary>
         /// <param name="parseWhere"></param>
         /// <returns>Если возвращается null, то вызывается метод <see cref="CustomerCachingCompile"/>, если он возвращает null, то вызывается метод <see cref="Compile"/></returns>
         protected virtual Func<string, bool> DoCachingCompile(Expression<Func<string, bool>> parseWhere)
         {
             var shouldCache = ShouldCache(parseWhere);
             if (shouldCache)
                 return _routeCompileCaches.GetOrAdd(parseWhere, key => parseWhere.Compile());
             return null;
         }
         protected virtual Func<string, bool> CustomerCachingCompile(Expression<Func<string, bool>> parseWhere)
         {
             return null;
         }
 ```Включение кэширования выражений может улучшить производительность маршрутизации, уменьшив время компиляции с 0.14 мс до 0.013 мс, что составляет приблизительно 10 раз быстрее. # Важные замечания
При использовании данного фреймворка обратите внимание на два момента: если ваш `ShardingDbContext` переопределил следующие службы, они могут не работать. Если вы хотите использовать их, вам потребуется самостоятельно переопределить расширение [см. пример](https://github.com/xuejmnet/sharding-core/blob/main/src/ShardingCore/DIExtension.cs)
1. `ShardingDbContext`
```c#
return optionsBuilder.UseShardingWrapMark()
                 .ReplaceService<IDbSetSource, ShardingDbSetSource>()
                 .ReplaceService<IQueryCompiler, ShardingQueryCompiler>()
                 .ReplaceService<IDbContextTransactionManager, ShardingRelationalTransactionManager<TShardingDbContext>>()
                 .ReplaceService<IRelationalTransactionFactory, ShardingRelationalTransactionFactory<TShardingDbContext>>();

return optionsBuilder.ReplaceService<IModelCacheKeyFactory, ShardingModelCacheKeyFactory>()
                 .ReplaceService<IModelCustomizer, ShardingModelCustomizer<TShardingDbContext>>();

# План
- [Предоставить официальный сайт, если проект будет успешным]
- [Разработать более полную документацию]
- [Переформатировать для поддержки других ORM .NET]

# Заключение
Этот фреймворк был создан, опираясь на идеи большинства компонентов для разделенных таблиц. В настоящее время все предоставляемые интерфейсы реализованы и поддерживают запросы к нескольким таблицам. Для запросов на основе пагинации фреймворк использует потоковое чтение, чтобы избежать переполнения памяти при пропуске больших объемов данных. В настоящее время это библиотека находится на ранней стадии разработки и имеет множество недоработок, поэтому просим прощения за возможные недостатки. Если вам понравился проект, пожалуйста, оставьте звезды.

Этот документ был создан ночью, и я надеюсь, что он будет полезен и привлечет больше внимания. Также я надеюсь, что он позволит людям общаться и обмениваться идеями.Этот фреймворк был создан с использованием отличного кода и идей из различных открытых экосистем .NET. Я надеюсь, что этот фреймворк сможет внести свой вклад в развитие экосистемы .NET. Я буду поддерживать этот проект на протяжении долгого времени. Если у вас есть предложения или идеи, пожалуйста, свяжитесь со мной по следующим контактам. Добро пожаловать к оставлению звезд!

# Донат
<img src="./imgs/zfb.jpg" title="JetBrains" width=200 />
<img src="./imgs/wx.jpg" title="JetBrains" width=222 />
[Блог](https://www.cnblogs.com/xuejiaming)

QQ-группа: 771630778

Личный QQ: 326308290 (добро пожаловать к технической поддержке и предоставлению ценных замечаний)

Личная почта: 326308290@qq.com