[Abp vNext 源碼分析] - 13. 本地事件匯流排與分散式事件匯流排 (Rabbit MQ)

来源:https://www.cnblogs.com/myzony/archive/2019/12/10/12017999.html

一、簡要介紹 ABP vNext 封裝了兩種事件匯流排結構,第一種是 ABP vNext 自己實現的本地事件匯流排,這種事件匯流排無法跨項目發佈和訂閱。第二種則是分散式事件匯流排,ABP vNext 自己封裝了一個抽象層進行定義,並使用 RabbitMQ 編寫了一個基本實現。 在使用方式上,兩種事件匯流排的作 ...


一、簡要介紹

ABP vNext 封裝了兩種事件匯流排結構,第一種是 ABP vNext 自己實現的本地事件匯流排,這種事件匯流排無法跨項目發佈和訂閱。第二種則是分散式事件匯流排,ABP vNext 自己封裝了一個抽象層進行定義,並使用 RabbitMQ 編寫了一個基本實現。

在使用方式上,兩種事件匯流排的作用基本相同。

事件匯流排分佈在兩個模塊,在 Volo.Abp.EventBus 模塊內部,定義了事件匯流排的抽象介面,以及本地事件匯流排 (ILocalEventBus) 的實現。分散式事件匯流排的具體實現,是在 Volo.Abp.EventBus.RabbitMQ 模塊內部進行定義,從項目名稱可以看出來,這個模塊是基於 RabbitMQ 消息隊列實現的。

但是該項目並不是直接引用 RabbitMQ.Client 包,而是在 Volo.Abp.RabbitMQ 項目內部引用。這是因為除了分散式事件匯流排以外,ABP 還基於 RabbitMQ 實現了一個後臺作業管理器。

ABP vNext 框架便將一些對象抽象出來,放在 Volo.Abp.RabbitMQ 項目內部進行定義和實現。

二、源碼分析

2.1 事件處理器的註冊

分析源碼,首先從一個項目的模塊開始,Volo.Abp.EventBus 庫的模塊 AbpEventBusModule 只幹了一件事情。在組件註冊的時候,根據組件的實現介面 (ILocalEventHandlerIDistributedEventHandler) 不同,將其賦值給 AbpLocalEventBusOptionsAbpDistributedEventBusOptionsHandlers 屬性。

也就是說,開發人員定義的事件處理程式 (Handler) 都會在依賴註入的時候,都會將其類型 (Type) 添加到事件匯流排的配置類當中,方便後續進行使用。

2.2 事件匯流排的介面

通過事件匯流排模塊的單元測試我們可以知道,事件的發佈與訂閱都是通過 IEventBus 的兩個子介面 (ILocalEventBus/IDistributedEventBus) 進行的。在 IEventBus 介面的定義中,有三種行為,分別是 發佈訂閱取消訂閱

對於 ILocalEventBus 介面和 IDistributedEventBus 介面來說,它們都提供了一個,針對本地事件處理器和分散式處理器的特殊訂閱方法。

ILocalEventBus

/// <summary>
/// Defines interface of the event bus.
/// </summary>
public interface ILocalEventBus : IEventBus
{
    /// <summary>
    /// Registers to an event. 
    /// Same (given) instance of the handler is used for all event occurrences.
    /// </summary>
    /// <typeparam name="TEvent">Event type</typeparam>
    /// <param name="handler">Object to handle the event</param>
    IDisposable Subscribe<TEvent>(ILocalEventHandler<TEvent> handler)
        where TEvent : class;
}

IDistributedEventBus

public interface IDistributedEventBus : IEventBus
{
    /// <summary>
    /// Registers to an event. 
    /// Same (given) instance of the handler is used for all event occurrences.
    /// </summary>
    /// <typeparam name="TEvent">Event type</typeparam>
    /// <param name="handler">Object to handle the event</param>
    IDisposable Subscribe<TEvent>(IDistributedEventHandler<TEvent> handler)
        where TEvent : class;
}

2.3 事件匯流排基本流程和實現

同其他模塊一樣,因為有分散式事件匯流排和本地事件匯流排,ABP vNext 同樣抽象了一個 EventBusBase 類型,作為它們的基類實現。

一般的流程,我們是先定義某個事件,然後訂閱該事件並指定事件處理器,最後在某個時刻發佈事件。例如下麵的代碼:

首先定義了一個事件處理器,專門用於處理 EntityChangedEventData<MyEntity> 事件。

public class MyEventHandler : ILocalEventHandler<EntityChangedEventData<MyEntity>>
{
    public int EntityChangedEventCount { get; set; }

    public Task HandleEventAsync(EntityChangedEventData<MyEntity> eventData)
    {
        EntityChangedEventCount++;
        return Task.CompletedTask;
    }
}
var handler = new MyEventHandler();

LocalEventBus.Subscribe<EntityChangedEventData<MyEntity>>(handler);

await LocalEventBus.PublishAsync(new EntityCreatedEventData<MyEntity>(new MyEntity()));

2.3.1 事件的訂閱

可以看到,這裡使用的是 ILocalEventBus 定義的訂閱方法,跳轉到內部實現,它還是調用的 EventBus 的方法。

public virtual IDisposable Subscribe<TEvent>(ILocalEventHandler<TEvent> handler) where TEvent : class
{
    // 調用基類的 Subscribe 方法,並傳遞 TEvent 的類型,和事件處理器。
    return Subscribe(typeof(TEvent), handler);
}
public virtual IDisposable Subscribe(Type eventType, IEventHandler handler)
{
    return Subscribe(eventType, new SingleInstanceHandlerFactory(handler));
}

可以看到,這裡傳遞了一個 SingleInstanceHandlerFactory 對象,這玩意兒是幹嘛用的呢?從名字可以看出來,這是一個工廠,是用來創建 Handler (事件處理器) 的工廠,並且是一個單實例的事件處理器工廠。

下麵就是 IEventHandlerFactory 介面的定義,以及 SingleInstanceHandlerFactory 實現。

public interface IEventHandlerFactory
{
    // 獲得一個事件處理器包裝對象,即事件處理器執行完畢之後,可以調用
    // IEventHandlerDisposeWrapper.Dispose() 進行釋放。
    IEventHandlerDisposeWrapper GetHandler();

    // 判斷在已有的事件處理器工廠集合中,是否已經存在了相同的事件處理器。
    bool IsInFactories(List<IEventHandlerFactory> handlerFactories);
}

public class SingleInstanceHandlerFactory : IEventHandlerFactory
{
    // 構造工廠時,傳遞的事件處理器實例。
    public IEventHandler HandlerInstance { get; }


    public SingleInstanceHandlerFactory(IEventHandler handler)
    {
        HandlerInstance = handler;
    }

    // 通過 EventHandlerDisposeWrapper 包裝事件處理器實例。
    public IEventHandlerDisposeWrapper GetHandler()
    {
        return new EventHandlerDisposeWrapper(HandlerInstance);
    }

    // 判斷針對 HandlerInstance 的事件處理器是否已經存在。
    public bool IsInFactories(List<IEventHandlerFactory> handlerFactories)
    {
        return handlerFactories
            .OfType<SingleInstanceHandlerFactory>()
            .Any(f => f.HandlerInstance == HandlerInstance);
    }
}

針對 IEventHandlerFactory 工廠,還擁有 3 個不同的實現,下表分別說明它們的應用場景。

實現類型 作用
IocEventHandlerFactory 每個工廠對應一個事件處理器的的類型,並通過 ScopeFactory 解析具體的事件處理器。生命周期由 scope 控制,當 scope 釋放時,對應的事件處理器實例也會被銷毀。
SingleInstanceHandlerFactory 每個工廠對應單獨的一個事件處理器實例,事件處理器實例是由創建者控制的。
TransientEventHandlerFactory 每個工廠對應一個事件處理器的類型,區別是它不由 IoC 解析實例,而是使用的 Activator.CreateInstance() 方法構造實例,是一個瞬時對象,調用包裝器的 Dispose 即會進行釋放。
TransientEventHandlerFactory<THandler> 每個工廠對應指定的 THandler 事件處理器,生命周期同上面的工廠一樣。

這幾種工廠都是在訂閱操作時,不同的訂閱重載使用不同的工廠,或者是自己指定事件處理器的工廠均可。

public virtual IDisposable Subscribe<TEvent, THandler>()
    where TEvent : class
    where THandler : IEventHandler, new()
{
    return Subscribe(typeof(TEvent), new TransientEventHandlerFactory<THandler>());
}

public virtual IDisposable Subscribe(Type eventType, IEventHandler handler)
{
    return Subscribe(eventType, new SingleInstanceHandlerFactory(handler));
}

不過有一種特殊的行為,開發人員可以 不用顯式訂閱。在 EventBus 類型中,定義了一個 SubscribeHandlers(ITypeList<IEventHandler> handlers) 方法。該方法接收一個類型集合,通過遍歷集合,從事件處理器的定義當中,取得事件處理器監聽的事件類型 TEvent

在取得了事件類型,並知曉了事件處理器類型以後,事件匯流排就可以訂閱 TEvent 類型的事件,並使用 IocEventHandlerFactory 工廠來構造事件處理器。

protected virtual void SubscribeHandlers(ITypeList<IEventHandler> handlers)
{
    // 遍歷事件處理器的類型,其實這裡的就是模塊啟動時,傳遞給 XXXOptions 的集合。
    foreach (var handler in handlers)
    {
        // 獲得事件處理器的所有介面定義,並遍歷介面進行檢查。
        var interfaces = handler.GetInterfaces();
        foreach (var @interface in interfaces)
        {
            // 如果介面沒有實現 IEventHandler 類型,則忽略。
            if (!typeof(IEventHandler).GetTypeInfo().IsAssignableFrom(@interface))
            {
                continue;
            }

            // 從泛型參數當中,獲得定義的事件類型。
            var genericArgs = @interface.GetGenericArguments();
            // 泛型參數完全匹配 1 時,才進行訂閱操作。
            if (genericArgs.Length == 1)
            {
                Subscribe(genericArgs[0], new IocEventHandlerFactory(ServiceScopeFactory, handler));
            }
        }
    }
}

這個訂閱方法在 EventBus 當中是一個抽象方法,分別在本地事件匯流排和分散式事件匯流排有實現,這裡我們首先講解本地事件的邏輯。

public class LocalEventBus : EventBusBase, ILocalEventBus, ISingletonDependency
{
    protected ConcurrentDictionary<Type, List<IEventHandlerFactory>> HandlerFactories { get; }

    public LocalEventBus(
        IOptions<AbpLocalEventBusOptions> options,
        IServiceScopeFactory serviceScopeFactory)
        : base(serviceScopeFactory)
    {
        Options = options.Value;
        Logger = NullLogger<LocalEventBus>.Instance;

        HandlerFactories = new ConcurrentDictionary<Type, List<IEventHandlerFactory>>();

        // 調用父類的方法,將模塊初始化時掃描到的事件處理器,都嘗試進行訂閱。
        SubscribeHandlers(Options.Handlers);
    }

    public override IDisposable Subscribe(Type eventType, IEventHandlerFactory factory)
    {
        GetOrCreateHandlerFactories(eventType)
            // 鎖住集合,以確保線程安全。
            .Locking(factories =>
                {
                    // 如果在集合內部,已經有了對應的工廠,則不進行添加。
                    if (!factory.IsInFactories(factories))
                    {
                        factories.Add(factory);
                    }
                }
            );

        // 返回一個事件處理器工廠註銷器,當調用 Dispose() 方法時,會取消之前訂閱的事件。
        return new EventHandlerFactoryUnregistrar(this, eventType, factory);
    }

    private List<IEventHandlerFactory> GetOrCreateHandlerFactories(Type eventType)
    {
        // 根據事件的類型,從字典中獲得該類型的所有事件處理器工廠。
        return HandlerFactories.GetOrAdd(eventType, (type) => new List<IEventHandlerFactory>());
    }
}

上述流程結合 EventBusLocalEventBus 講解了事件的訂閱流程,事件的訂閱操作都是對 HandlerFactories 的操作,往裡面添加指定事件的事件處理器工廠,而每個工廠都是跟具體的事件處理器實例/類型進行關聯的。

2.3.2 事件的發佈

當開發人員需要發佈事件的時候,一般都是通過對應的 EventBus,調用響應的 PublishAsync 方法,傳遞要觸發的事件類型與事件數據。介面和基類當中,定義了兩種發佈方法的簽名與實現:

public virtual Task PublishAsync<TEvent>(TEvent eventData) where TEvent : class
{
    return PublishAsync(typeof(TEvent), eventData);
}

public abstract Task PublishAsync(Type eventType, object eventData);

第二種方法一共也分為本地事件匯流排的實現,和分散式事件匯流排的實現,本地事件比較簡單,我們先分析本地事件匯流排的實現。

public override async Task PublishAsync(Type eventType, object eventData)
{
    // 定義了一個異常集合,用於接收多個事件處理器執行時,產生的所有異常。
    var exceptions = new List<Exception>();

    // 觸發事件處理器。
    await TriggerHandlersAsync(eventType, eventData, exceptions);

    // 如果有任何異常產生,則拋出到之前的調用棧。
    if (exceptions.Any())
    {
        if (exceptions.Count == 1)
        {
            exceptions[0].ReThrow();
        }

        throw new AggregateException("More than one error has occurred while triggering the event: " + eventType, exceptions);
    }
}

可以看到真正的觸發行為是在 TriggerHandlersAsync(Type eventType, object eventData, List<Exception> exceptions) 內部進行實現的。

protected virtual async Task TriggerHandlersAsync(Type eventType, object eventData, List<Exception> exceptions)
{
    // 針對於這個的作用,等同於 ConfigureAwait(false) 。
    // 具體可以參考 https://blogs.msdn.microsoft.com/benwilli/2017/02/09/an-alternative-to-configureawaitfalse-everywhere/。
    await new SynchronizationContextRemover();

    // 根據事件的類型,得到它的所有事件處理器工廠。
    foreach (var handlerFactories in GetHandlerFactories(eventType))
    {
        // 遍歷所有的事件處理器工廠,通過 Factory 獲得事件處理器,調用 Handler 的 HandleEventAsync 方法。
        foreach (var handlerFactory in handlerFactories.EventHandlerFactories)
        {
            await TriggerHandlerAsync(handlerFactory, handlerFactories.EventType, eventData, exceptions);
        }
    }

    // 如果類型繼承了 IEventDataWithInheritableGenericArgument 介面,那麼會檢測泛型參數是否有父類。
    // 如果有父類,則會使用當前的事件數據,為其父類發佈一個事件。
    if (eventType.GetTypeInfo().IsGenericType &&
        eventType.GetGenericArguments().Length == 1 &&
        typeof(IEventDataWithInheritableGenericArgument).IsAssignableFrom(eventType))
    {
        var genericArg = eventType.GetGenericArguments()[0];
        var baseArg = genericArg.GetTypeInfo().BaseType;
        if (baseArg != null)
        {
            // 構造基類的事件類型,使用當前一樣的泛型定義,只是泛型參數使用基類。
            var baseEventType = eventType.GetGenericTypeDefinition().MakeGenericType(baseArg);
            // 構建類型的構造參數。
            var constructorArgs = ((IEventDataWithInheritableGenericArgument)eventData).GetConstructorArgs();
            // 通過事件類型和構造參數,構造一個新的事件數據實例。
            var baseEventData = Activator.CreateInstance(baseEventType, constructorArgs);
            // 發佈父類的同類事件。
            await PublishAsync(baseEventType, baseEventData);
        }
    }
}

在上述代碼內部,都還沒有真正執行事件處理器,真正的事件處理器執行程式是在下麵的方法進行執行的。ABP vNext 通過引入 IEventDataWithInheritableGenericArgument 介面,實現了 類型繼承事件 的觸發,該介面提供了一個 GetConstructorArgs() 方法定義,方便後面生成構造參數。

例如有一個基礎事件叫做 EntityEventData<Student>,如果 Student 繼承自 Person,那麼在觸發該事件的時候,也會發佈一個 EntityEventData<Person> 事件。

2.3.3 事件處理器的執行

真正事件處理器的執行,是通過下麵的方法實現的,大概思路就是通過事件匯流排工廠,構建了事件處理器的實例。通過反射,調用事件處理器的 HandleEventAsync() 方法。如果在處理過程當中,出現了異常,則將異常數據放置在 List<Exception> 集合當中。

protected virtual async Task TriggerHandlerAsync(IEventHandlerFactory asyncHandlerFactory, Type eventType, object eventData, List<Exception> exceptions)
{
    using (var eventHandlerWrapper = asyncHandlerFactory.GetHandler())
    {
        try
        {
            // 獲得事件處理器的類型。
            var handlerType = eventHandlerWrapper.EventHandler.GetType();

            // 判斷事件處理器是本地事件還是分散式事件。
            if (ReflectionHelper.IsAssignableToGenericType(handlerType, typeof(ILocalEventHandler<>)))
            {
                // 獲得方法定義。
                var method = typeof(ILocalEventHandler<>)
                    .MakeGenericType(eventType)
                    .GetMethod(
                        nameof(ILocalEventHandler<object>.HandleEventAsync),
                        new[] { eventType }
                    );

                // 使用工廠創建的實例調用方法。
                await (Task)method.Invoke(eventHandlerWrapper.EventHandler, new[] { eventData });
            }
            else if (ReflectionHelper.IsAssignableToGenericType(handlerType, typeof(IDistributedEventHandler<>)))
            {
                var method = typeof(IDistributedEventHandler<>)
                    .MakeGenericType(eventType)
                    .GetMethod(
                        nameof(IDistributedEventHandler<object>.HandleEventAsync),
                        new[] { eventType }
                    );

                await (Task)method.Invoke(eventHandlerWrapper.EventHandler, new[] { eventData });
            }
            else
            {
                // 如果都不是,則說明類型不正確,拋出異常。
                throw new AbpException("The object instance is not an event handler. Object type: " + handlerType.AssemblyQualifiedName);
            }
        }
        // 捕獲到異常都統一添加到異常集合當中。
        catch (TargetInvocationException ex)
        {
            exceptions.Add(ex.InnerException);
        }
        catch (Exception ex)
        {
            exceptions.Add(ex);
        }
    }
}

2.4 分散式事件匯流排

分散式事件匯流排的實現都存放在 Volo.Abp.EventBus.RabbitMQ,該項目的代碼比較少,由三個文件構成。

在 RabbitMQ 模塊的內部,只幹了兩件事情。首先從 JSON 配置文件當中,獲取 AbpRabbitMqEventBusOptions 配置的三個參數,然後解析 RabbitMqDistributedEventBus 實例,並調用初始化方法 (Initialize())。

[DependsOn(
    typeof(AbpEventBusModule),
    typeof(AbpRabbitMqModule))]
public class AbpEventBusRabbitMqModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        var configuration = context.Services.GetConfiguration();

        // 從配置文件讀取配置。
        Configure<AbpRabbitMqEventBusOptions>(configuration.GetSection("RabbitMQ:EventBus"));
    }

    public override void OnApplicationInitialization(ApplicationInitializationContext context)
    {
        // 調用初始化方法。
        context
            .ServiceProvider
            .GetRequiredService<RabbitMqDistributedEventBus>()
            .Initialize();
    }
}

2.4.1 分散式事件匯流排的初始化

public void Initialize()
{
    // 創建一個消費者,並配置交換器和隊列。
    Consumer = MessageConsumerFactory.Create(
        new ExchangeDeclareConfiguration(
            AbpRabbitMqEventBusOptions.ExchangeName,
            type: "direct",
            durable: true
        ),
        new QueueDeclareConfiguration(
            AbpRabbitMqEventBusOptions.ClientName,
            durable: true,
            exclusive: false,
            autoDelete: false
        ),
        AbpRabbitMqEventBusOptions.ConnectionName
    );

    // 消費者在消費消息的時候,具體的執行邏輯。
    Consumer.OnMessageReceived(ProcessEventAsync);

    // 調用基類的方法,自動訂閱對應的事件。
    SubscribeHandlers(AbpDistributedEventBusOptions.Handlers);
}

2.4.2 分散式事件的訂閱

在定義分散式事件的時候,我們必須使用 EventNameAttribute 為事件聲明路由鍵。

public override IDisposable Subscribe(Type eventType, IEventHandlerFactory factory)
{
    var handlerFactories = GetOrCreateHandlerFactories(eventType);

    if (factory.IsInFactories(handlerFactories))
    {
        return NullDisposable.Instance;
    }

    handlerFactories.Add(factory);

    if (handlerFactories.Count == 1) //TODO: Multi-threading!
    {
        // 為消費者綁定一個路由鍵,在收到對應的事件時,就會觸發之前綁定的方法。
        Consumer.BindAsync(EventNameAttribute.GetNameOrDefault(eventType));
    }

    return new EventHandlerFactoryUnregistrar(this, eventType, factory);
}

訂閱的時候,除了 Consumer.BindAsync() 以外,基本流程和本地事件匯流排基本一致。

2.4.3 分散式事件的發佈

分散式事件匯流排一樣重寫了發佈方法,內部首先使用 IRabbitMqSerializer 序列化器 (基於 JSON.NET) 將事件數據進行序列化,然後將消息投遞出去。

public override Task PublishAsync(Type eventType, object eventData)
{
    var eventName = EventNameAttribute.GetNameOrDefault(eventType);
    // 序列化事件數據。
    var body = Serializer.Serialize(eventData);

    // 創建一個通道用於通訊。
    using (var channel = ConnectionPool.Get(AbpRabbitMqEventBusOptions.ConnectionName).CreateModel())
    {
        channel.ExchangeDeclare(
            AbpRabbitMqEventBusOptions.ExchangeName,
            "direct",
            durable: true
        );
        
        // 更改投遞模式為持久化模式。
        var properties = channel.CreateBasicProperties();
        properties.DeliveryMode = RabbitMqConsts.DeliveryModes.Persistent;

        // 發佈一個新的事件。
        channel.BasicPublish(
            exchange: AbpRabbitMqEventBusOptions.ExchangeName,
            routingKey: eventName,
            mandatory: true,
            basicProperties: properties,
            body: body
        );
    }

    return Task.CompletedTask;
}

2.4.4 分散式事件的執行

執行邏輯都存放在 ProcessEventAsync(IModel channel, BasicDeliverEventArgs ea) 方法內部,基本就是監聽到指定的消息,首先反序列化消息,調用父類的 TriggerHandlersAsync 去執行具體的事件處理器。

private async Task ProcessEventAsync(IModel channel, BasicDeliverEventArgs ea)
{
    var eventName = ea.RoutingKey;
    var eventType = EventTypes.GetOrDefault(eventName);
    if (eventType == null)
    {
        return;
    }

    var eventData = Serializer.Deserialize(ea.Body, eventType);

    await TriggerHandlersAsync(eventType, eventData);
}

三、總結

ABP vNext 為我們實現了比較完善的本地事件匯流排,和基於 RabbitMQ 的分散式事件匯流排。在平時開發過程中,我們本地事件匯流排的使用頻率應該還是比較高,而分散式事件匯流排目前仍處於一個半成品,很多高級特性還沒實現,例如重試策略等。所以分散式事件匯流排要使用的話,建議使用較為成熟的 CAP 庫替代 ABP vNext 的分散式事件匯流排。

四、其他

360 大病救助 : 在這裡向大家求助一下,病人是我親戚,情況屬實。對於他們家庭來說,經濟壓力很大,希望大家能幫助或轉發一下,謝謝大家。


您的分享是我們最大的動力!

更多相關文章
  • Scala中sortBy是以方法的形式存在的,並且是作用在Array或List集合排序上,並且這個sortBy預設只能升序,除非實現隱式轉換或調用reverse方法才能實現降序,Spark中sortBy是運算元,作用出發RDD中數據進行排序,預設是升序可以通過該運算元的第二參數來實現降序排序的方式 ...
  • 本筆記摘抄自:https://www.cnblogs.com/zhili/archive/2012/07/23/Mutex_And_Semaphore.html,記錄一下學習過程以備後續查用。 一、信號量(Semaphore) 信號量(Semaphore)是由內核對象維護的int變數。當信號量為0時 ...
  • 1.24小時時間格式制定 按照2019-12-10-13-00-00格式輸出:string dtnow = string.Format("{0:yyyy-MM-dd-HH-mm-ss}", DateTime.Now); //24小時制 按照2019-12-10-01-00-00格式輸出:string ...
  • 當新建一個core項目後,使用identity基架後,確認郵件出現了錯誤,並不能正常使用。 建立文檔在這裡 https://docs.microsoft.com/zh-cn/aspnet/core/security/authentication/scaffold-identity?view=aspn ...
  • From https://www.cnblogs.com/zjbky/p/9242140.html ...
  • using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Data; using System.Co... ...
  • 1 //要執行的業務是從阿裡雲上下載將近40000條的音頻到本地,單條下載忒慢,就想採用多線程,分配了二十個線程同時下載,省了很大部分的時間 class Program 2 { 3 4 static void Main(string[] args) { 5 string sql = "select ... ...
  • 1.Anchor屬性設置 1.Anchor屬性設置 1.Anchor屬性設置 對需要設置的控制項,如主窗體中的TextBox,設置Anchor為上下左右都停靠,就會實現隨著窗體的變化而變化。 2.AutoScaleMode屬性的用法:《轉自:https://www.cnblogs.com/lmcblo ...
一周排行
  • 【五分鐘的dotnet】是一個利用您的碎片化時間來學習和豐富.net知識的博文系列。如果您現在正在使用.NetCore的話,相信您對await 和 async這兩個關鍵字再熟悉不過了。它們是為非同步編程提供的語法糖,便於我們在代碼中更便捷的進行非同步操作。await 和 async其實是對Task對象都... ...
  • .NET基金會是一個獨立的非營利組織,於2014年成立,旨在圍繞 .NET 不斷增長的開源技術集合,促進開放開發和協作。它是商業和社區開發人員的論壇,通過促進開放性,社區參與和快速創新來增強.NET生態系統的未來。要使.NET 基金會真正獨立並由社區運營,則需要獨立資助。過去,.NET 基金會依靠來... ...
  • 微信公眾號: "Dotnet9" ,網站: "Dotnet9" ,問題或建議: "請網站留言" , 如果對您有所幫助: "歡迎贊賞" 。 .NET CORE(C ) WPF 方便的實現用戶控制項切換(祝大家新年快樂) 快到2020年了,祝大家新年快樂,今年2019最後一更,謝謝大家支持! 閱讀導航 1 ...
  • 內容有點多,請耐心! 最近公司的有這個業務需求,又很湊巧讓我來完成: 首先想要對接,先要一個公眾號,再就是開發文檔了:https://developers.weixin.qq.com/doc/offiaccount/Getting_Started/Overview.html 不過請註意這一點 ok, ...
  • MyBatis MyBatis是Apache的一個開源項目iBatis, iBatis一詞來源於“internet”和“abatis”的組合,是一個基於Java的持久層框架。 iBatis 提供的持久層框架包括SQL Maps和Data Access Objects(DAO) Mybatis 是一個 ...
  • 前言 Stanley B.Lippman 先生所著的《C++ Primer》是學習C++的一本非常優秀的教科書,但《C++ Primer》作為一本大部頭書,顯然不適合所有的初學者。所以Lippman先生又返璞歸真地寫了這本短小輕薄的《Essentia C++》。這本書以簡短的章節篇幅,幫助初學者快速... ...
  • 大數據環境需要的安裝包合集,包括: apache flume 1.7.0 bin.tar.gz apache hive 1.2.1 bin.tar.gz hadoop 2.7.2.tar.gz hbase 1.3.1 bin.tar.gz jdk 8u144 linux x64.tar kafka_ ...
  • 在項目當中資料庫一般都會成為主要的性能與負載瓶頸,那麼針對資料庫各項性能指標的監控與對應的優化是開發與運維人員需要面對的主要工作,而且這部分的工作會貫穿項目從開發到運行的整個周期里。 這篇文章中我們對MySql資料庫中的幾個主要的性能指標的計算與統計進行下說明與總結。 在MySql中通過show g ...
  • 1. Cookie Cookie,有時也用其複數形式Cookies,指某些網站為了辨別用戶身份、進行session跟蹤而儲存在用戶本地終端上的數據(通常經過加密)。Cookie最早是網景公司的前雇員Lou Montulli在1993年3月的發明。Cookie是由伺服器端生成,發送給User-Agen ...
  • 1. PreparedStatement預編譯的語句對象 預編譯語句PreparedStatement 是java.sql中的一個介面,它是Statement的子介面。通過Statement對象執行SQL語句時,需要將SQL語句發送給DBMS,由 DBMS首先進行編譯後再執行。預編譯語句和State ...
x