AspNetCore企业级开发

#pragma once
#include <stdio.h>
#include <stdlib.h>
//没有访问权限控制
//数据和函数分离
//缺少限定
struct Person
{
	int age;
};
//无参构造器
Person* person_new()
{
	return person_new(0);
}
//带参构造器
Person* person_new(int age)
{
	Person* ts = (Person*)malloc(sizeof(Person));
	if (ts != NULL)
	{
		ts->age = age;
		return ts;
	}
	return NULL;
}
//由于数据和函数的分离，导致必须通过前缀来进行限定
//ts即面向对象语言中的this
int person_get_age(Person* ts)
{
	return ts->age;
}

void person_set_age(Person* ts, int age)
{
	ts->age = age;
}

void person_do_some1(Person* ts)
{
	printf("%d", ts->age);
}
//静态函数本质就是全局函数，但是没有限定
void person_do_some2()
{
	Person* ts = person_new();
	if (ts != NULL)
	{
		printf("%d", ts->age);
	}
}
void test()
{
	//实列化
	Person* student = person_new(20);
	printf("%d\n", student->age);
	person_set_age(student, 20);
	//调用实列函数
	person_do_some1(student);
	//调用全局函数(静态函数)
	person_do_some2();
}

public class Person
{
    /// <summary>
    /// 字段：用于保存数据,用来抽象事物的属性
    /// </summary>
    private int age;

    /// <summary>
    /// 属性：用于控制字段的访问权限和逻辑
    /// 注意：属性是特殊的实列函数
    /// </summary>
    public int Age
    {
        get
        {
            //访问逻辑
            return age;
        }
        set
        {
            //访问逻辑
            age = value;
        }
    }
    /// <summary>
    /// 实列函数：实列相关，所有的实列函数都有this（属性也有），代之当前实列。
    /// </summary>
    public void DoSome1()
    {
        Console.WriteLine(this.Age);
    }

    /// <summary>
    /// 静态函数：类型相关，所有可访问的范围都能访问。
    /// 注意：静态函数无法访问实列函数，本质是因为没有this
    /// </summary>
    public static void DoSome2()
    {
        //Console.WriteLine(this.Age);//错误没有this
        var obj = new Person();
        obj.DoSome1();//间接调用
    }

    /// <summary>
    /// 事件：事件既不是字段也不是属性，就是事件，没有getter,setter
    /// 注意：事件的类型必须是委托
    /// 站在oop的角度来看委托的本质是接口，java就是通过接口来实现委托的。
    /// </summary>
    public event Action<Person>? OnSleep = null;

    public void Sleep()
    {
        //发布，触发事件
        OnSleep?.Invoke(this);
    }
    /// <summary>
    /// 静态属性：注意区分属性和字段的区别（是否有get|set）
    /// </summary>
    public static string Name { get; }
    /// <summary>
    /// 
    /// </summary>
    static Person()
    {
        Name = "Person";
    }
    /// <summary>
    /// 无参构造：默认提供，如果提供了带参构造则不提供无参构造，及构造器至少有一个
    /// 注意：构造器也是特殊的实列函数
    /// </summary>
    public Person() 
        : this(0)
    {

    }
    /// <summary>
    /// 带参构造
    /// </summary>
    /// <param name="age"></param>
    public Person(int age)
    {
        this.age = age;
    }
}

public class Person
{
    private int id;
    public int Id { get { return id;} }
    /// <summary>
    /// 实列函数
    /// </summary>
    public void DoSome1()
    {
        Console.WriteLine(id);
    }
    /// <summary>
    /// 虚函数：虚函数可以重写
    /// </summary>
    public virtual void DoSome2()
    {

    }
    /// <summary>
    /// 实列函数
    /// </summary>
    public static void DoSome3()
    {

    }
}
/// <summary>
/// 继承：子类继承父类所有代码（注意“所有”二字）
/// </summary>
public class Student : Person
{
    public void Test1()
    {
        //可以理解成这三个方法都在Student里面所已可以调用
        DoSome1();
        DoSome2();
        DoSome3();
    }
    public static void Test2()
    {
        //可以理解成这三个方法都在Student里面所已可以调用
        DoSome1();//静态函数的无法调用实列函数（可以理解成自己的实列函数）
        DoSome3();
    }
    public void Test3()
    {
        //访问不了不代表没有继承。试想子类中没有id字段，那么Id属性拿到的是谁的值？
        Console.WriteLine(base.id);//无法直接访问父类中的私有成员
        Console.WriteLine(Id);//可以通过公开的方法或者属性来间接访问
    }
    /// <summary>
    /// 重写：子类可以重写父类的虚函数
    /// </summary>
    public override void DoSome2()
    {
        //base是代词，代指父类的实列
        base.DoSome2();//显示调用父类中的DoSome2
        //this是代词，代指当前的实列
        this.DoSome1();
    }
    /// <summary>
    /// 覆盖：子类可以覆盖父类中的实列函数
    /// </summary>
    public new void DoSome1()
    {
        
    }
}

public abstract class Animal
{
    public virtual void Say()
    {
        Console.WriteLine("呜呜呜~~~");
    }
}
public class Dog : Animal
{
    public override void Say()
    {
        Console.WriteLine("汪汪汪~~~");
    }
}
public class Cat : Animal
{
    public override void Say()
    {
        Console.WriteLine("喵喵喵~~~");
    }
}
public class Program
{
    public static void Main(string[] args)
    {
        //object是所有类的超类(超类就是基类的基类)
        object animal2 = new Dog();
        animal2.Say();//编译时无法通过
        //可以进行转换              
        var dog1 = animal2 as Dog;
        dog1?.Say();
        var dog2 = animal2 as Animal;
        dog2?.Say();
        //转换失败
        var cat = animal2 as Cat;
        cat?.Say();

        //多态：父类型的引用可以指向子类型的对象
        Animal animal1 = new Dog();
        //编译时：函数与引用的类型绑定
        //运行时：函数与实列的类型绑定
        //编译时会检查Animal是否有Say函数，运行时执行实列的函数
        animal1.Say();
    }
}

public class Person
{
            
}
public class Student : Person
{
            
}
public interface IPerson1<T>
{
    
}
/// <summary>
/// 逆变
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IPerson2<in T>
{

}
/// <summary>
/// 协变
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IPerson3<out T>
{

}

public void Test1()
{
    //泛型是不完整的类型，指定泛型参数之后才完整
    IPerson1<Person>? p1 = null;
    IPerson1<Student>? p2 = null;
    //IPerson1<Person>和IPerson1<Student>不存在继承关系
    //p1 = p2;
}
public void Test2()
{
    //泛型是不完整的类型，指定泛型参数之后才完整
    IPerson2<Person>? p1 = null;
    IPerson2<Student>? p2 = null;
    //IPerson1<Person>和IPerson1<Student>不存在继承关系，但是支持逆变
    p2 = p1;
}

public void Test3()
{
    //泛型是不完整的类型，指定泛型参数之后才完整
    IPerson3<Person>? p1 = null;
    IPerson3<Student>? p2 = null;
    //IPerson1<Person>和IPerson1<Student>不存在继承关系，但是支持协变
    p1 = p2;
}

public void Test4()
{
    //协变的应用
    IEnumerable<object>? p1 = null;
    IEnumerable<string>? p2 = null;
    p1 = p2;
}

public IEnumerable<int> GetRandomNumberList(int count)
{
    for (int i = 0; i < count; i++)
    {
        yield return Random.Shared.Next();//使用yield编译器会给你取实现IEnumerable接口
    }
}

public class RandomNumber : IEnumerable<int>
{
    private int[] list;
  
    public RandomNumber(int count)
        {
            list = new int[count];
            for (int i = 0; i < count; i++)
            {
                var item = Random.Shared.Next();
                list[i] = item;
            }
        }

    public IEnumerator<int> GetEnumerator()
    {
        return new Enumerator(this);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    class Enumerator : IEnumerator<int>
    {
        private readonly RandomNumber obj;
        private int _index = -1;
        public Enumerator(RandomNumber obj)
        {
            this.obj = obj;
        }
        public int Current => obj.list[_index];

        object IEnumerator.Current => Current;

        public void Dispose()
        {
            
        }

        public bool MoveNext()
        {
            //迭代器一般用内部类
            //内部内可以访问到外部类的私有成员
            if (_index < obj.list.Length)
            {
                _index++;
                return true;
            }
            return false;
        }

        public void Reset()
        {
            _index = -1;
        }
    }
}

public class IConnection 
{

}
public class SqlConnection : IConnection
{

}
public class DbContext
{
    //DbContext依赖IConnection
	public DbContext(IConnection connection)
	{
	
	}
}
IConnection connection = new SqlConnectioon();
//注入：手动注入，容器可以自动注入
var context = new DbContext(connection);

//创建容器
IServiceCollection services = new ServiceCollection();
//1.通过ServiceDescriptor创建，写框架时有用（万能公式）
services.Add(new ServiceDescriptor(typeof(IConnection),typeof(SqlConnection),ServiceLifetime.Singleton));
//2.泛型方式，此时服务类型为IConnection
services.AddSingleton<IConnection, SqlConnection>();
//3.委托注册，可以定义创建逻辑，在注册服务时也能解析服务
services.AddSingleton(sp => 
{
    //sp:是容器实列可以用于解析以注册的服务(IServiceProvider)
    var connection = sp.GetService<IConnection>();
    return new DbContext(connection,"fff");
    //高级
	//return ActivatorUtilities.CreateInstance<IConnection>(sp,"fff");
});
//4.服务类型和实现类型相同
services.AddSingleton<SqlConnection>();
//5.泛型注册，这样可以获取到所有Logger<>的完整类型（泛型参数不要写死）
services.AddSingleton(typeof(Logger<>));
//6.反射的方式，写框架很有用
services.AddSingleton(typeof(SqlConnection));
//7.注意使用反射构建泛型参数，此时注册的是Logger<Program>服务（ps：写框架的人会用到）
services.AddSingleton(typeof(Logger<>).MakeGenericType(typeof(Program)));  
//8.替换服务,如果服务已注册则不进行注册。一般写框架会用到，如果框架使用了Try...那么你可以使用自定义的服务在它之前进行替换
services.TryAddSingleton(typeof(SqlConnection));

public class Connection
{

}

public class ConnectionFactory
{
    private IServiceProvider _serviceProvider;
    private Dictionary<string, Type> _connections;

    public ConnectionFactory(IServiceProvider provider, Dictionary<string, Type> connections)
    {
        _serviceProvider = provider;
        _connections = connections;
    }

    public Connection? Get(string name)
    {
        if (_connections.TryGetValue(name, out Type? connectionType))
        {
            return _serviceProvider.GetService(connectionType) as Connection;                
        }
        return default;
    }
}

public class Connection
{

}
public class ConnectionFactoryBuilder
{
    private Dictionary<string, Connection> _connections = new();

    public ConnectionFactoryBuilder Add(string name,Connection connection)
    {
        _connections.Add(name, connection);
        return this;//一般要支持链式调用
    }

    public ConnectionFactory Build()
    {
        return new ConnectionFactory(_connections);
    }
}
public static class ConnectionFactoryBuilderExtensions
{
    public static ConnectionFactoryBuilder Add(this ConnectionFactoryBuilder builder, Connection connection)
    {
        var name = connection.GetType().Name;
        builder.Add(name, connection);
        return this;//一般要支持链式调用
    }
}

public interface IConfigurationProvider
{
	string Get(string key);
}

public class JsonConfigurationProvider: IConfigurationProvider
{

}
public class XmlConfigurationProvider : IConfigurationProvider
{

}

public class ConfigurationManager
{
	private List<IConfigurationProvider> _providers = new (); 
    
    public void AddProvider(IConfigurationProvider provider)
    {
        _providers.Add(provider);
    }
    
    public string Get(string key)
    {
        foreach(var item in _providers)
        {
            var value = item.Get(key);
            if(value != null)
            {
                return value;
            }    
        }
        return default;
    }
}

IServiceCollection services = new ServiceCollection();
services.AddSingleton<IConnection, SqlConnection>();
services.AddSingleton<IConnection, MySqlConnection>();
services.AddSingleton<AService>();
IServiceProvider container = services.BuildServiceProvider();
var connection = container.GetRequiredService<IConnection>();
var service = container.GetService<AService>();
Console.WriteLine(connection.GetType().Name);

//创建容器
IServiceCollection services = new ServiceCollection();
//注册服务
services.AddSingleton<IConnection, SqlConnection>();
//构建容器
IServiceProvider container = services.BuildServiceProvider();
//解析服务
var connection = container.GetService<IConnection>();
//解析服务，如果解析不到会抛出异常
var connection = container.GetRequiredService<IConnection>();
//解析所有IConnection类型的服务
IEnumerable<IConnection> connections = container.GetServices<IConnection>();
//解析一个没有注册到容器但是依赖了容器已注册的服务，写框架常用
ActivatorUtilities.CreateInstance<DbContext>(container);

public class Connection
{
    public string Id { get; }

    //每次实列化的时候执行一次，得到一个唯一id
    public Connection()
    {
        Id = Guid.NewGuid().ToString();
    }
}
var services = new ServiceCollection();
services.AddScoped<Connection>();
var container = services.BuildServiceProvider(new ServiceProviderOptions()
{
    ValidateScopes = true,//指示是否可以通过根容器来解析Scope实列。
	ValidateOnBuild = true//构建之前时检查是否有依赖没有注册的服务	
});
//测试scoped
var connection1 = container.GetRequiredService<Connection>();
Console.WriteLine(connection1.Id);
using(var scope = container.CreateScope())
{
    var connection2 = scope.ServiceProvider.GetRequiredService<Connection>();
    Console.WriteLine(connection2.Id);
}

//定义一个注解
[AttributeUsage(AttributeTargets.Class)]
public class InjectionAttribute : Attribute
{
    public Type? ServiceType { get; set; }
    public ServiceLifetime Lifetime { get; set; } = ServiceLifetime.Transient;
}
public static class DependencyInjectionExtensions
{
    //扫描
    public static IServiceCollection AddInjectionServices<T>(this IServiceCollection services)
    {
        var serviceTypes = GetInjectionServiceTypeList(typeof(T).Assembly);
        foreach (var item in serviceTypes)
        {
            var injection = item.GetCustomAttribute<InjectionAttribute>();
            if (injection!.ServiceType == null)
            {
                services.Add(new ServiceDescriptor(item, item, injection.Lifetime));
            }
            else
            {
                services.Add(new ServiceDescriptor(injection!.ServiceType, item, injection.Lifetime));
            }
        }
        return services;
    }

    private static IEnumerable<Type> GetInjectionServiceTypeList(Assembly assembly)
    {
        var serviceType = assembly.GetTypes()
            .Where(a => a.IsClass)
            .Where(a => a.GetCustomAttribute<InjectionAttribute>() != null)
            .Where(a => !a.IsAbstract);
        return serviceType;
    }
}

public interface ILogger<T>
{
    void Log();
}
//注入
[Injection(ServiceType = typeof(ILogger<>), Lifetime = ServiceLifetime.Singleton)]
internal class Logger<T>: ILogger<T>
{
    public void Log()
    {
        Console.WriteLine(typeof(T).Name+"：success！");
    }
}
public static void TestScanner()
{
     var services = new ServiceCollection();
     //扫描组件
     services.AddInjectionServices<Program>();
     var container = services.BuildServiceProvider();
     var logger = container.GetRequiredService<ILogger<Program>>();
     logger.Log();
}

public static void TestAutofac()
{
    var services = new ServiceCollection();
    //微软的容器注册服务
    services.AddScoped(typeof(ILogger<>),typeof(Logger<>));
    var builder = new ContainerBuilder();
    //autofac容器注册服务
    builder.RegisterType<CService>().PropertiesAutowired()
        .As<CService>()
        .InstancePerLifetimeScope();
    builder.Populate(services);//将IServiceCollection中的服务注册到autofac
    //使用AutofacServiceProvider的实现方案，创建容器
    //加载autofac中的服务
    IServiceProvider container = new AutofacServiceProvider(builder.Build());
    var logger = container.GetRequiredService<ILogger<Program>>();
    var service = container.GetRequiredService<CService>();
}

//创建配置管理器
ConfigurationManager configuration = new ConfigurationManager();
configuration.SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("config.json")//添加json文件
    .AddEnvironmentVariables();//添加系统环境变量
//打印环境变量
Console.WriteLine(configuration.GetSection("path").Value);
//读取josn
var student = configuration.GetSection("student");
Console.WriteLine(student["name"]);
Console.WriteLine(configuration["student:name"]);
//类型转换：需要安装Microsoft.Extensions.Configuration.Binder支持
Console.WriteLine(configuration.GetSection("student:age").Get<int>());

//配置提供器选项：用于提供配置选项
public class IsonConfigurationSource : IConfigurationSource
{
    public string? Url { get; set; }
    public bool ReloadOnChange { get; set; }

    public IsonConfigurationSource()
    {

    }

    public IsonConfigurationSource(string url)
    {
        Url = url;
    }

    public IConfigurationProvider Build(IConfigurationBuilder builder)
    {
        if (Url == null)
        {
            throw new ArgumentNullException(nameof(Url));
        }
        return new IsonConfigurationProvider(this);
    }
}
//配置提供器：配置源逻辑
public class IsonConfigurationProvider : IConfigurationProvider
{
    private ConcurrentDictionary<string, string> values = new ConcurrentDictionary<string, string>();
    private IsonConfigurationSource options;
    private CancellationTokenSource? tokenSource;
    public IsonConfigurationProvider(IsonConfigurationSource options)
    {
        this.options = options;
        //如果需要监听
        if (this.options.ReloadOnChange)
        {
            Watch();
        }
    }
    private void Watch()
    {
        //注册事件
        ChangeToken.OnChange(GetReloadToken, () =>
        {
            Load();

        });
        //模拟更改
        var t = new Thread(() =>
        {

            while (true)
            {
                var token = tokenSource;
                tokenSource = null;
                //每3s之后发生更改
                Thread.Sleep(3000);
                //触发事件,触发之前一定要将tokenSource设置成null
                token!.Cancel();
            }
        });
        t.Start();
    }
    public IEnumerable<string> GetChildKeys(IEnumerable<string> earlierKeys, string parentPath)
    {
        return values.Keys;
    }

    public IChangeToken GetReloadToken()
    {
        lock (this)
        {
            if (tokenSource == null)
            {
                tokenSource = new CancellationTokenSource();
            }
            return new CancellationChangeToken(tokenSource!.Token);
        }
    }

    public void Load()
    {
        //假设我们从第三方地址获取
        //var client = new HttpClient();
        //var response = client.GetAsync(source.Url).GetAwaiter().GetResult();
        //var json = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
        values.TryAdd("t1", "1111111");
        values.TryAdd("t2", "2222222");
        Console.WriteLine("ison文件已加载...");
    }

    public void Set(string key, string value)
    {
        values.TryAdd(key, value);
    }

    public bool TryGet(string key, out string value)
    {
        var flag = values.TryGetValue(key, out string? data);
        value = data ?? string.Empty;
        return flag;
    }
}


//扩展IConfigurationBuilder
public static class IsonConfigurationExtensions
{
    public static IConfigurationBuilder AddJsonUrl(this IConfigurationBuilder builder, string url)
    {
        if (builder == null)
        {
            throw new ArgumentNullException(nameof(builder));
        }
        if (string.IsNullOrEmpty(url))
        {
            throw new ArgumentException(nameof(url));
        }

        return builder.Add(new IsonConfigurationSource(url));
    }

    public static IConfigurationBuilder AddJsonUrl(this IConfigurationBuilder builder, Action<IsonConfigurationSource> configure)
    {
        if (builder == null)
        {
            throw new ArgumentNullException(nameof(builder));
        }

        var source = new IsonConfigurationSource();
        configure(source);//执行用户配置
        return builder.Add(source);
    }

internal class Program
{
    static void Main(string[] args)
    {
        var provider = new FileConfigurationProvider();
        //绑定
        provider.Watch();
        new TaskCompletionSource().Task.Wait();
    }
}

/// <summary>
/// 文件配置程序超类
/// </summary>
public class FileConfigurationProvider
{
    private CancellationTokenSource? tokenSource;

    public void Load()
    {
        Console.WriteLine($"[{DateTime.Now}]文件已加载...");
    }

    public void Watch()
    {
        //将changeToken生产者和changeToken消费者进行绑定(订阅)
        ChangeToken.OnChange(GetReloadToken, Load);
        //触发Change事件，通知更新
        var t = new Thread(() =>
        {
            while (true)
            {
                Thread.Sleep(3000);
                var t = tokenSource;
                tokenSource = null;
                //注意，取消之前一定要将tokenSource设置成null，不然会引发堆栈异常
                //因为通知了取消，就会获取changeChange，但是你没有设置成null，OnChange认为又发生了取消通知
                //会一直循环
                t!.Cancel();//执行回调，发布取消事件。
            }
        });
        t.Start();
    }

    /// <summary>
    /// 更新令牌，通过该令牌可以注册回调，用于执行更新通知。
    /// </summary>
    /// <returns></returns>
    public IChangeToken GetReloadToken()
    {
        lock (this)
        {
            //如果被消费就创建一个新的
            if (tokenSource == null)
            {
                tokenSource = new CancellationTokenSource();
            }
            return new CancellationChangeToken(tokenSource.Token);
        }
    }

}

//创建日志工厂，注意这里的设计模式，用到了Factory和Builder模式
ILoggerFactory factory = LoggerFactory.Create(configure =>
{
    //configure是ILoggingBuilder用于构建配置Factory
    //需要Microsoft.Extensions.Logging.Console的支持
    configure.AddConsole(c => 
    {
    	c.FormatterName = ConsoleFormatterNames.Simple;
    });
    //需要Microsoft.Extensions.Logging.Debug的支持
    configure.AddDebug();
    //configure.AddFile();//自定义扩展
    configure.SetMinimumLevel(LogLevel.Information);
});
//获取一个名为Program的日志实列
//注意：CreateLogger返回的是微软的一个实现，里面做了大量的封装，用于简化你的封装成本。
ILogger<Program> logger1 = factory.CreateLogger<Program>();
//有时候无法使用泛型的使用可以使用这个api
ILogger logger2 = factory.CreateLogger(nameof(Program));
//推荐使用占位符，而不是字符串拼接，因为字符串拼接即使日志不打印，也要拼接即调用ToString，性能不行
logger1.LogInformation("Hello World!{0}", DateTime.Now);//只有打印的时候，才会计算Now并且调用ToString

public class LoggingBuilder : ILoggingBuilder
{
    public IServiceCollection Services { get; }

    public LoggingBuilder(IServiceCollection services)
    {
        Services = services;
    }
}
//创建一个容器
var services = new ServiceCollection();
//注册日期工厂和ILogger泛型实现
services.AddLogging();
//创建日志Builder
var loggingBuilder = new LoggingBuilder(services);
//注意loggingBuilder会把服务注册到我们的现有容器里
loggingBuilder.AddConsole();

ILoggerFactory factory = LoggerFactory.Create(configure =>
{
    configure.AddConsole(c =>
    {
        c.FormatterName = ConsoleFormatterNames.Simple;
    });
    //作用于所有日志提供程序
    configure.AddFilter((categorName, level) =>
    {
        if (categorName.StartsWith("Microsoft.EntityFramework"))
        {
            return true;
        }
        return false;
    });
    //只作用与指定日志提供程序
    //configure.AddFilter<ConsoleLoggerProvider>((categorName, level) =>
    //{
    //    if (categorName.StartsWith("Microsoft.EntityFramework"))
    //    {
    //        return true;
    //    }
    //    return false;
    //});
});
var logger1 = factory.CreateLogger("Microsoft.EntityFramework");
var logger2 = factory.CreateLogger("Microsoft.AspNetCore");
//推荐使用占位符，而不是字符串拼接，因为字符串拼接即使日志不打印，也要拼接，调用toString性能不行
logger1.LogInformation("fff{0}", DateTime.Now);
logger2.LogInformation("fff", DateTime.Now);

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Information",
      "Microsoft.EntityFramework": "Warning"
    },
    "Console": {
      "LogLevel": {
        "Default": "Information",
        "Microsoft.AspNetCore": "Information",
        "Microsoft.EntityFramework": "Information"
      }
    },
    "File": {
      "LogLevel": {
        "Default": "Information",
        "Microsoft.AspNetCore": "Information",
        "Microsoft.EntityFramework": "Warning"
      }
    }
  }
}

//创建配置
var configuration = new ConfigurationManager();
configuration.SetBasePath(Directory.GetCurrentDirectory());
configuration.AddJsonFile("config.json");
ILoggerFactory factory = LoggerFactory.Create(configure =>
{
    //使用配置文件
    configure.AddConfiguration(configuration.GetSection("Logging"));
    configure.AddConsole(c =>
    {
        c.FormatterName = ConsoleFormatterNames.Simple;
    });
    configure.AddFile();
});

factory.CreateLogger("Microsoft.EntityFramework").LogInformation("ef core..");
factory.CreateLogger("Microsoft.AspNetCore").LogInformation("aspnet core..");
factory.CreateLogger("HuaJianDao.Logging").LogInformation("logging..");

//日志提供程序
//指定提供程序别名：配置时有用
[ProviderAlias("File")]
public class FileLoggerProvider : ILoggerProvider
{
    public FileLoggerProvider()
    {

    }
    
    private LoggerExternalScopeProvider ScopeProvider = new LoggerExternalScopeProvider();
    
    public ILogger CreateLogger(string categoryName)
    {
        var logger = new FileLogger(categoryName, ScopeProvider);
        logger.ScopeProvider = new LoggerExternalScopeProvider();
        return logger;
    }

    public void Dispose()
    {
        //用于释放资源
    }
}
//日志记录器
internal class FileLogger : ILogger
{
    private readonly string categoryName;
   
    public IExternalScopeProvider ScopeProvider { get; set; }
    
    public FileLogger(string categoryName, IExternalScopeProvider scopeProvider)
    {
        this.categoryName = categoryName;
        this.ScopeProvider= scopeProvider;
    }
   
    public IDisposable BeginScope<TState>(TState state)
    {
        return ScopeProvider.Push(state);
    }

    public bool IsEnabled(LogLevel logLevel)
    {
        return logLevel != LogLevel.None;
    }

    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
    {
        var currentPath = Directory.GetCurrentDirectory();
        var path = Path.Combine(currentPath, $"{DateTime.Now:yyyy-MM-dd}.log");
        var message = formatter(state,exception);
        System.IO.File.AppendAllText(path, $"{logLevel}: {categoryName} {DateTime.Now}\r\n{message}\r\n");
    }
}
//文件扩展
public static class FileLoggerExtensions
{
    public static ILoggingBuilder AddFile(this ILoggingBuilder builder)
    {
        builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider, FileLoggerProvider>());
        return builder;
    }
}

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.nlog-project.org/schemas/NLog.xsd NLog.xsd"
      autoReload="true"
      throwExceptions="false"
      internalLogLevel="Off" internalLogFile="c:\temp\nlog-internal.log">
	<!--
	  See https://github.com/nlog/nlog/wiki/Configuration-file
	  for information on customizing logging rules and outputs.
   -->
	<targets>
		<!--
		add your targets here
		See https://github.com/nlog/NLog/wiki/Targets for possible targets.
		See https://github.com/nlog/NLog/wiki/Layout-Renderers for the possible layout renderers.
		 -->
		<target xsi:type="File" name="f" fileName="${basedir}/logs/${shortdate}.log"
		   layout="${longdate} ${uppercase:${level}} ${message}" />
		<target xsi:type="Console" name="c"
		   layout="${longdate} ${uppercase:${level}} ${message}" />
	</targets>

	<rules>
		<logger name="*" minlevel="Debug" writeTo="f,c" />
	</rules>
</nlog>

public static void TestNLog()
{
    //https://nlog-project.org/config
    ILoggerFactory factory = LoggerFactory.Create(configure =>
    {
    //使用配置文件
    configure.AddNLog();//面向微软的接口编程，可以享受第三方的扩展
    configure.AddConsole();
    });
    var logger = factory.CreateLogger<ILogger<Program>>();
    logger.LogInformation("uuuuuuuuuu");
}

public static IServiceCollection Configure<TOptions>(this IServiceCollection services, string name, Action<TOptions> configureOptions)
    where TOptions : class
{
    if (services == null)
    {
        throw new ArgumentNullException(nameof(services));
    }

    if (configureOptions == null)
    {
        throw new ArgumentNullException(nameof(configureOptions));
    }

    services.AddOptions();
    services.AddSingleton<IConfigureOptions<TOptions>>(new ConfigureNamedOptions<TOptions>(name, configureOptions));
    return services;
}

//注册Options核心组件 
public static IServiceCollection AddOptions(this IServiceCollection services)
{
     if (services == null)
     {
         throw new ArgumentNullException(nameof(services));
     }

     services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptions<>), typeof(UnnamedOptionsManager<>)));
     services.TryAdd(ServiceDescriptor.Scoped(typeof(IOptionsSnapshot<>), typeof(OptionsManager<>)));
     services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptionsMonitor<>), typeof(OptionsMonitor<>)));
     services.TryAdd(ServiceDescriptor.Transient(typeof(IOptionsFactory<>), typeof(OptionsFactory<>)));
     services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptionsMonitorCache<>), typeof(OptionsCache<>)));
     return services;
}

public class MvcOptions
{
    public string Uri { get; }
}
static void TestSort()
{
    var services = new ServiceCollection();
    //name为Empty
    services.Configure<MvcOptions>(a =>
    {
        Console.WriteLine(11);
        a.Url = "132";
    });
    services.PostConfigure<MvcOptions>(a =>
    {
        Console.WriteLine(33);
        a.Url = "132";
    });
    services.Configure<MvcOptions>(a =>
    {
        Console.WriteLine(22);
        a.Url = "132";
    });
    services.PostConfigure<MvcOptions>(a =>
    {
        Console.WriteLine(44);
        a.Url = "132";
    });
    var sp = services.BuildServiceProvider();
    var optionsFactory = sp.GetRequiredService<IOptionsFactory<MvcOptions>>();
    var options = optionsFactory.Create(Options.DefaultName);
}

//1.通过委托来配置选项，同一个选项可以按顺序执行多个Configure。
services.Configure<MvcOptions>(a => 
{
	a.Url = "132";
});
//2.在所有的Configure执行之后配置选项。同一个选项可以按顺序执行多个PostConfigure。
services.PostConfigure<MvcOptions>(a =>
{
	a.Url = "132";
});
//AddOptions返回一个OptionsBuilder，可以连续配置选项，本质还是执行Configure和PostConfigure
services.AddOptions<MvcOptions>()
	.Bind(configuration.GetSection("MvcOptions"))
    .Configure(a=>a.Url="123");

var services = new ServiceCollection();
services.Configure<MvcOptions>(a =>
{
    a.Url = "132";
});
var sp = services.BuildServiceProvider();
var optionsFactory = sp.GetRequiredService<IOptionsFactory<MvcOptions>>();
var options = sp.GetRequiredService<IOptions<MvcOptions>>();
var optionsMonitor = sp.GetRequiredService<IOptionsMonitor<MvcOptions>>();
var optionsSnapshot = sp.GetRequiredService<IOptionsSnapshot<MvcOptions>>();

static void TestDiOptions()
{
    var services = new ServiceCollection();
    services.Configure<MvcOptions>(a =>
    {
        Console.WriteLine(22);
        a.Url = "132";
    });
    services.AddSingleton(sp => 
    {
        return sp.GetRequiredService<IOptions<MvcOptions>>().Value;
    });
    //必须使用Scoped，因为IOptionsSnapshot是Scoped的,如果是单实列的话，就丢失了自动更改的性质了
    //services.AddScoped(sp =>
    //{
    //    return sp.GetRequiredService<IOptionsSnapshot<MvcOptions>>().Value;
    //});
    var sp = services.BuildServiceProvider();
    var options = sp.GetRequiredService<MvcOptions>();
}

{
  "MvcOptions": {
    "Url": "123"
  },
  "WebOptions": {
    "Url": 456
  }
}

public class MvcOptions
{
    public string? Url { get; set; }
}

static void OnChange()
{
    var services = new ServiceCollection();
    var configuration = GetConfiguration();
    services.Configure<MvcOptions>(configuration.GetSection("MvcOptions"));
    var container = services.BuildServiceProvider();
    while (true)
    {
        Thread.Sleep(1000);
        using (var scope = container.CreateScope())
        {
            var o1 = scope.ServiceProvider.GetRequiredService<IOptions<MvcOptions>>();
            var o2 = scope.ServiceProvider.GetRequiredService<IOptionsSnapshot<MvcOptions>>();
            var o3 = scope.ServiceProvider.GetRequiredService<IOptionsMonitor<MvcOptions>>();
            Console.WriteLine("==================");
            Console.WriteLine($"IOptions:{o1.Value.Url}");
            Console.WriteLine($"IOptionsSnapshot:{o2.Value.Url}");
            Console.WriteLine($"IOptionsMonitor:{o3.CurrentValue.Url}");
            o3.OnChange(o =>
            {
                Console.WriteLine("选项发生更改了");
            });
        }
    }
}

static IConfiguration GetConfiguration()
{
    var configuration = new ConfigurationManager();
    configuration.SetBasePath(Directory.GetCurrentDirectory());
    configuration.AddJsonFile("config.json", false, true);
    return configuration;
}

{
  "MvcOptions": {
    "Url": "123"
  },
  "WebOptions": {
    "Url": 456
  }
}

public class MvcOptions
{
    public string? Url { get; set; }
}
 
static void TestNamed()
{
    var services = new ServiceCollection();
    var configuration = GetConfiguration();
    //name=Options.DefaultName
    services.Configure<MvcOptions>(configuration.GetSection("MvcOptions"));
    //name="o1"
    services.Configure<MvcOptions>("o1", configuration.GetSection("MvcOptions"));
    //name="o2"
    services.Configure<MvcOptions>("o2", configuration.GetSection("WebOptions"));
    var container = services.BuildServiceProvider();
    var o1 = container.GetRequiredService<IOptionsSnapshot<MvcOptions>>();
    var o2 = container.GetRequiredService<IOptionsMonitor<MvcOptions>>();
    //name="o1"
    Console.WriteLine("IOptionsSnapshot:Named:" + o1.Get("o1").Url);
    //name=Options.DefaultName
    Console.WriteLine("IOptionsSnapshot:Value:" + o1.Value.Url);
    //name="o2"
    Console.WriteLine("IOptionsMonitor:Named:" + o2.Get("o2").Url);
    //name=Options.DefaultName
    Console.WriteLine("IOptionsMonitor:Value:" + o2.CurrentValue.Url);
    var optionsFactory = sp.GetRequiredService<IOptionsFactory<MvcOptions>>();
    var options = optionsFactory.Create(Options.DefaultName);
}

//通过该源码发现，我们可以通过实现IPostConfigureOptions接口，并注入到容器来进行配置选项
public static IServiceCollection PostConfigure<TOptions>(this IServiceCollection services, string name, Action<TOptions> configureOptions)
    where TOptions : class
{
    if (services == null)
    {
        throw new ArgumentNullException(nameof(services));
    }

    if (configureOptions == null)
    {
        throw new ArgumentNullException(nameof(configureOptions));
    }

    services.AddOptions();
    services.AddSingleton<IPostConfigureOptions<TOptions>>(new PostConfigureOptions<TOptions>(name, configureOptions));
    return services;
}

public class MvcOptions
{
    public string? Url { get; set; }
}
//你也可以实现IConfigureOptions但是IConfigureOptions的执行顺序优先级比较低（要学会举一反三）
internal class MvcOptionsPostConfigureOptions : IPostConfigureOptions<MvcOptions>
{
    public void PostConfigure(string name, MvcOptions options)
    {
        options.Url = "789";
        //可以编写验证逻辑
        //if (options.Url == "123")
        //{
        //    throw new InvalidDataException("Url不能等于123");
        //}
    }
}
public static void TestIPostConfigureOptions()
{
    var services = new ServiceCollection();
    services.Configure<MvcOptions>(s => s.Url = "111");
    services.AddSingleton<IPostConfigureOptions<MvcOptions>, MvcOptionsPostConfigureOptions>();
    var container = services.BuildServiceProvider();
    var o2 = container.GetRequiredService<IOptions<MvcOptions>>();
}

internal class MvcOptionsDep
{
    public void Configure(MvcOptions options)
    {
        options.Url = "6666";
    }
}
public static void TestDep()
{
    var services = new ServiceCollection();
    //注册di服务
    services.AddSingleton<MvcOptionsDep>();
    services.AddOptions<MvcOptions>()//注册选项
        .Configure(a=>a.Url="123")//第一个配置
        .PostConfigure<MvcOptionsDep>((options, dep) => //后续配置
        {
            dep.Configure(options);//调用MvcOptionsDep中的方法来进行配置
        });
    var container = services.BuildServiceProvider();
    var o2 = container.GetRequiredService<IOptions<MvcOptions>>();
}

public static void TestValidateDelegate()
{
    try
    {
        var services = new ServiceCollection();
        //不是把选项注入到容器，只是注入了该选项的委托
        services.Configure<MvcOptions>(a => a.Url = "123");
        //得到OptionsBuilder，进行验证，本质还是执行Configure（可以执行无数多个Configre）
        services.AddOptions<MvcOptions>()
            .Validate(options => 
            {
                if (options.Url == null)
                {
                    return false;
                }
                if (!options.Url.StartsWith("aa"))
                {
                    return false;
                }
                return true;
            }, "必须以aa开头");
        var container = services.BuildServiceProvider();
        var options = container.GetRequiredService<IOptions<MvcOptions>>();
        Console.WriteLine(options.Value.Url);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}

public class MvcOptions
{
    [RegularExpression(@"^aa",ErrorMessage ="必须以aa开头")]
    public string? Url { get; set; }
}

public static void TestValidateDataAnnotations()
{
    try
    {
        var services = new ServiceCollection();
        //不是把选项注入到容器，只是注入了该选项的委托
        services.Configure<MvcOptions>(a => a.Url = "123");
        //得到OptionsBuilder，进行验证，本质还是执行Configure（可以执行无数多个Configre）
        services.AddOptions<MvcOptions>()
            .ValidateDataAnnotations();
        var container = services.BuildServiceProvider();
        var options = container.GetRequiredService<IOptions<MvcOptions>>();
        Console.WriteLine(options.Value.Url);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}

//侵入式方案，把这个看懂。后面就是围绕这个开展，高出非侵入式
public static void A()
{
    Console.WriteLine("A:开始");
    B();//A，B的调用关系强行绑定，有侵入性
    Console.WriteLine("A:结束");
}
public static void B()
{
    Console.WriteLine("B:开始");
    C();
    Console.WriteLine("B:结束");
}
public static void C()
{
    Console.WriteLine("Hello World");
}
public static void Dobasic()
{
    A();
}

 /// <summary>
/// 定义标准1
/// </summary>
public interface IPhoneService
{ 
    string Mobile { get; set; }
    string Message { get; set; }
    void Send();
}
//实现标准-不是代理模式
public class PhoneService : IPhoneService
{
    public string Mobile { get; set; }
    public string Message { get; set; }

    public PhoneService(string mobile, string message)
    {
        Mobile = mobile;
        Message = message;
    }

    public virtual void Send()
    {
        Console.WriteLine($"已发送短信：{Message}到{Mobile}");
    }
}
//代理模式：
//1.实现目标对象的标准
//2.依赖目标对象（被代理对象）
//3.业务织入
public class PhoneServiceProxy : IPhoneService//实现标准
{
    private readonly IPhoneService _target;

    public PhoneServiceProxy1(IPhoneService target)
    {
        _target = target;
    }

    public string Mobile { get => _target.Mobile; set => _target.Mobile = value; }
    public string Message { get => _target.Message; set => _target.Message = value; }

    /// <summary>
    /// 子类重写父类方法
    /// </summary>
    public void Send()
    {
        Console.WriteLine("Proxy1:已对手机号进行验证");
        _target.Send();
        Console.WriteLine("Proxy1:已确认对方已经收到");
    }
}

/// <summary>
/// 定义标准1
/// </summary>
public interface IPhoneService
{
    string Mobile { get; set; }
    string Message { get; set; }
    void Send();
}
/// <summary>
/// 定义标准2
/// </summary>
public interface IEmailService
{
    string Email { get; set; }
    string Message { get; set; }
    void Send();
}
/// <summary>
/// 业务逻辑1
/// </summary>
public class PhoneService : IPhoneService
{
    public string Mobile { get; set; }
    public string Message { get; set; }

    public PhoneService(string mobile, string message)
    {
        Mobile = mobile;
        Message = message;
    }

    public virtual void Send()
    {
        Console.WriteLine($"已发送短信：{Message}到{Mobile}");
    }
}
/// <summary>
/// 业务逻辑2
/// </summary>
public class EmailService : IEmailService
{
    public string Email { get; set; }
    public string Message { get; set; }

    public EmailService(string email, string message)
    {
        Email = email;
        Message = message;
    }

    public virtual void Send()
    {
        Console.WriteLine($"已发送邮件：{Message}到{Email}");
    }
}

/// <summary>
/// 切面1：校验能力（系统逻辑）
/// taget方式
/// </summary>
public class PhoneServiceProxy1
    : IPhoneService//实现标准1
{
    private readonly IPhoneService _target;

    public PhoneServiceProxy1(IPhoneService target)
    {
        _target = target;
    }

    /// <summary>
    /// 子类重写父类方法
    /// </summary>
    public void Send()
    {
        Console.WriteLine("Proxy1:已对手机号进行验证");
        _target.Send();
        Console.WriteLine("Proxy1:已确认对方已经收到");
    }
}
/// <summary>
/// 切面2：加速能力（系统逻辑）
/// </summary>
public class PhoneServiceProxy2
   : IPhoneService//实现标准1
{
    private readonly IPhoneService _target;

    public PhoneServiceProxy2(IPhoneService target)
    {
        _target = target;
    }

    /// <summary>
    /// 子类重写父类方法
    /// </summary>
    public void Send()
    {
        Console.WriteLine("Proxy2:已开启加速通道");
        _target.Send();
        Console.WriteLine("Proxy2:已关闭加速通道");
    }
}
//test
public static void TestStaticProxy()
{
    //目标对象
    IPhoneService target = new PhoneService("10088", "你好啊！");
    //切面1：验证，对target进行代理
    IPhoneService proxy1 = new PhoneServiceProxy1(target);
    //切面2：加速，对proxy1进行代理
    IPhoneService proxy2 = new PhoneServiceProxy2(proxy1);
    //执行
    proxy2.Send();
    //思考如果要实现IEmailService标准，是不是要重写实现类了？
}