Repository: CatLib/Core
Branch: 2.0
Commit: 98a7b1db446d
Files: 114
Total size: 544.0 KB

Directory structure:
gitextract_rz18cs7b/

├── .dist/
│   ├── CHANGELOG.md
│   ├── LICENSE
│   ├── README.md
│   ├── bucket.json
│   └── netstandard2.0/
│       ├── CatLib.Core.deps.json
│       └── CatLib.Core.pdb
├── .gitattributes
├── .github/
│   └── ISSUE_TEMPLATE/
│       ├── ---bug-report.md
│       ├── ---documentation-issue.md
│       ├── ---feature-request.md
│       └── ---support-question.md
├── .gitignore
├── .travis.yml
├── CHANGELOG.md
├── CatLib.Core.sln
├── LICENSE
├── README.md
├── bucket.json
├── build.ps1
└── src/
    ├── CatLib.Core/
    │   ├── CatLib/
    │   │   ├── App.cs
    │   │   ├── Application.cs
    │   │   ├── DebugLevel.cs
    │   │   ├── Events/
    │   │   │   ├── AfterBootEventArgs.cs
    │   │   │   ├── AfterInitEventArgs.cs
    │   │   │   ├── AfterTerminateEventArgs.cs
    │   │   │   ├── ApplicationEventArgs.cs
    │   │   │   ├── ApplicationEvents.cs
    │   │   │   ├── BeforeBootEventArgs.cs
    │   │   │   ├── BeforeInitEventArgs.cs
    │   │   │   ├── BeforeTerminateEventArgs.cs
    │   │   │   ├── BootingEventArgs.cs
    │   │   │   ├── InitProviderEventArgs.cs
    │   │   │   ├── RegisterProviderEventArgs.cs
    │   │   │   └── StartCompletedEventArgs.cs
    │   │   ├── Facade.cs
    │   │   ├── IApplication.cs
    │   │   ├── IBootstrap.cs
    │   │   ├── IServiceProvider.cs
    │   │   ├── ServiceProvider.cs
    │   │   └── StartProcess.cs
    │   ├── CatLib.Core.csproj
    │   ├── Container/
    │   │   ├── BindData.cs
    │   │   ├── BindDataExtension.cs
    │   │   ├── Bindable.cs
    │   │   ├── Container.cs
    │   │   ├── ContainerExtension.cs
    │   │   ├── GivenData.cs
    │   │   ├── IBindData.cs
    │   │   ├── IBindable.cs
    │   │   ├── IContainer.cs
    │   │   ├── IGivenData.cs
    │   │   ├── IMethodBind.cs
    │   │   ├── IParams.cs
    │   │   ├── InjectAttribute.cs
    │   │   ├── MethodBind.cs
    │   │   ├── MethodContainer.cs
    │   │   ├── ParamsCollection.cs
    │   │   ├── UnresolvableException.cs
    │   │   └── VariantAttribute.cs
    │   ├── EventDispatcher/
    │   │   ├── EventDispatcher.cs
    │   │   ├── IEventDispatcher.cs
    │   │   └── IStoppableEvent.cs
    │   ├── Exception/
    │   │   ├── AssertException.cs
    │   │   ├── LogicException.cs
    │   │   └── RuntimeException.cs
    │   ├── IO/
    │   │   ├── CombineStream.cs
    │   │   ├── RingBufferStream.cs
    │   │   ├── SegmentStream.cs
    │   │   ├── StreamExtension.cs
    │   │   └── WrapperStream.cs
    │   ├── Properties/
    │   │   └── AssemblyInfo.cs
    │   └── Util/
    │       ├── Arr.cs
    │       ├── Guard.cs
    │       ├── InternalHelper.cs
    │       ├── SortSet.cs
    │       └── Str.cs
    ├── CatLib.Core.Tests/
    │   ├── CatLib/
    │   │   ├── TestsApplication.cs
    │   │   └── TestsFacade.cs
    │   ├── CatLib.Core.Tests.csproj
    │   ├── Container/
    │   │   ├── TestsBindData.cs
    │   │   ├── TestsContainer.cs
    │   │   └── TestsExtensionContainer.cs
    │   ├── EventDispatcher/
    │   │   └── TestsEventDispatcher.cs
    │   ├── Fixture/
    │   │   ├── AbstractClass.cs
    │   │   ├── Bar.cs
    │   │   ├── Baz.cs
    │   │   ├── CircularDependency.cs
    │   │   ├── Foo.cs
    │   │   ├── FooBar.cs
    │   │   ├── Fubar.cs
    │   │   ├── FubarChild.cs
    │   │   ├── IFoo.cs
    │   │   ├── Position.cs
    │   │   ├── Quux.cs
    │   │   ├── QuuxFoo.cs
    │   │   ├── TestEventArgs.cs
    │   │   ├── Variant.cs
    │   │   └── VariantModel.cs
    │   ├── Framework/
    │   │   ├── ExpectedExceptionAndMessageAttribute.cs
    │   │   ├── TestException.cs
    │   │   └── TestMethodIterativeAttribute.cs
    │   ├── IO/
    │   │   ├── TestsCombineStream.cs
    │   │   ├── TestsRingBuffer.cs
    │   │   ├── TestsSegmentStream.cs
    │   │   └── TestsStreamExtension.cs
    │   └── Util/
    │       ├── TestsArr.cs
    │       ├── TestsGuard.cs
    │       ├── TestsSortSet.cs
    │       └── TestsStr.cs
    ├── Directory.Build.props
    ├── analysis.ruleset
    ├── analysis.test.ruleset
    ├── settings.runsettings
    └── stylecop.json

================================================
FILE CONTENTS
================================================

================================================
FILE: .dist/CHANGELOG.md
================================================
# Release Notes

## [v2.0.0-alpha.1 (2019-12-04)](https://github.com/CatLib/Core/releases/tag/v2.0.0) 

#### Added

- `Inject` allowed to be set to optional.(#253 )
- `Arr.Test` can get matched value of the first match(#280 )

#### Changed

- Comments translated from Chinese into English(#133 )
- Defined Container.Build as a virtual function(#210 )
- Optimizes the constructor of `MethodContainer`(#218 )
- The default project uses the .net standard 2.0(#225 )
- Rename Util helper class to Helper class Change access level to internal.(#230 )
- `Application.IsRegisted` changed(rename) to `IsRegistered`(#226 ) 
- Use `VariantAttribute` to mark variable types instead of `IVariant`(#232 )
- `Guard` Will be expandable with `Guard.That`(#233 )
- Fixed the problem of container exception stack loss(#234 )
- Adjusted the internal file structure to make it clearer(#236 ).
- Add code analyzers (#206 )
- Refactoring event system (#177 )
- Refactoring `RingBuffer` make it inherit from `Stream`.(#238 )
- Namespace structure adjustment(optimization).(#241 )
- `App` can be extended by `That` (Handler rename to that) and removed `HasHandler` API (#242 )
- Unnecessary inheritance: WrappedStream(#247 )
- Clean up useless comment(#249 ).
- `Guard.Require` can set error messages and internal exceptions(#250).
- Exception class implementation support: SerializationInfo build(#252 ).
- Refactoring unit test, import moq.(#255 )
- `CodeStandardException` replaces to `LogicException`(#257 )
- Exception move to namespace `CatLib.Exception`(#258 )
- `Facade<>.Instance` changed to `Facade<>.That`(#259 )
- `Application.StartProcess` migrate to `StartProcess`(#260 )
- `Arr` optimization, lifting some unnecessary restrictions (#263)
- `Str` optimization, lifting some unnecessary restrictions (#264)
- Refactoring `SortSet`(#265 )
- Removed global params in application constructor. use Application.New() instead.(#267 )
- Containers are no longer thread-safe by default(#270 )

#### Fixed

- Fixed a bug that caused `Arr.Fill` to not work properly under special circumstances. (#255 )

#### Removed

- Removed `ExcludeFromCodeCoverageAttribute` (#229 )
- Removed unnecessary interface design `ISortSet`(#211 ).
- Removed `Version` classes and `Application.Compare` method.(#212).
- Removed `Template`  supported(#213 ).
- Removed `FilterChain` supported(#214 ).
- Removed `Enum` supported(#215 ).
- Removed `IAwait` interface(#217 ).
- Removed `Container.Flash`  api(#219 ).
- Removed `Arr.Flash` method(#220 ).
- Removed `Dict` helper class(#221 ).
- Removed `ThreadStatic` helper class(#223 ).
- Removed `QuickList` supported(#224 ).
- Removed `Storage` supported(#228 )
- Removed `SystemTime` class(#235 ).
- Removed `ICoroutineInit` feature from core library(#243 ).
- Removed the priority attribute, depending on the loading order(#244 ).
- Removed `Util.Encoding` (#245 ).
- Removed `Str.Encoding`(#246 )
- Removed `IServiceProviderType` feature in core library(#246 ).
- Removed unnecessary extension functions(#247 ).
- Removed `PipelineStream` stream.(#256 )
- Removed all `Obsolete` method and clean code.(#261 )
- Removed `App.Version`.(#266 )


================================================
FILE: .dist/LICENSE
================================================
MIT License

Copyright (c) 2017 CatLib

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: .dist/README.md
================================================
<p align="center"><img width="173" height="57" src="https://catlib.io/imgs/logo-txt.png"></p>

<p align="center">
<a href="https://github.com/Catlib/Core/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" title="license-mit" /></a>
<a href="https://www.nuget.org/packages/catlib.core/"><img src="https://badge.fury.io/nu/catlib.core.svg" title="Nuget Version" /></a>
<a href="https://travis-ci.com/CatLib/Core"><img src="https://travis-ci.com/CatLib/Core.svg?branch=master" title="Build status"/></a>
<a href="https://codecov.io/gh/CatLib/Core">
  <img src="https://codecov.io/gh/CatLib/Core/branch/master/graph/badge.svg" alt="Codecov" />
</a>
<a href="https://github.com/CatLib/Core/releases">
  <img src="https://img.shields.io/nuget/dt/CatLib.Core.svg" alt="Downloads" />
</a>
</p>

## About CatLib

`CatLib` is the lightweight dependency injection container and helper functions library. 

- [Service Provider](https://catlib.io/lasted/architecture/service-provider.html)
- [Application](https://catlib.io/lasted/architecture/application.html)
- [IOC Container](https://catlib.io/lasted/architecture/container.html)
- [Facades](https://catlib.io/lasted/architecture/facade.html)

## Install CatLib Core

**Installed with Nuget**

```PM
$ Install-Package CatLib.Core -Version 2.0.0
```

**Installed with [Bucket](https://github.com/getbucket/bucket)**

```shell
$ bucket require catlib/core
```

**Installed with Github Release**

[Download the latest version](https://github.com/CatLib/Core/releases)。

## Learning CatLib

CatLib has the most extensive and thorough [documentation](https://catlib.io), making it a breeze to get started with the framework.

> 需要中文支持? 请访问[CatLib中文文档](https://zh.catlib.io)。

## Contribution

CatLib is still a young framework, and her growth and your contribution are inseparable. If you want to contribute to the project, please refer to: [CatLib Contribution Guide](https://catlib.io/lasted/contribution.html) Your contribution will be included in the list of contributors，Welcome Pull Request!

## License

The open source license used by CatLib is [MIT license](http://opensource.org/licenses/MIT).

## Support

* email: support@catlib.io
* slack: [catlib.slack](https://catlib.slack.com/messages/internals/)


================================================
FILE: .dist/bucket.json
================================================
{
	"name": "catlib/core",
	"version": "2.0.0",
	"description": "catlib framework is the lightweight dependency injection container and helper functions library.",
	"keywords": ["framework", "catlib"],
	"license": "MIT",
	"homepage": "https://catlib.io",
	"support": {
		"issues": "https://github.com/CatLib/Core/issues",
		"source": "https://github.com/CatLib/Core"
	},
	"authors": [
		{
			"name": "Meng han Yu",
			"email": "menghanyu1994@gmail.com"
		}
	]
}


================================================
FILE: .dist/netstandard2.0/CatLib.Core.deps.json
================================================
{
  "runtimeTarget": {
    "name": ".NETStandard,Version=v2.0/",
    "signature": ""
  },
  "compilationOptions": {},
  "targets": {
    ".NETStandard,Version=v2.0": {},
    ".NETStandard,Version=v2.0/": {
      "CatLib.Core/0.2.0-alpha.1+37a93a5": {
        "dependencies": {
          "Microsoft.CodeAnalysis.CSharp": "3.3.1",
          "Microsoft.CodeAnalysis.FxCopAnalyzers": "2.9.6",
          "NETStandard.Library": "2.0.3",
          "SonarAnalyzer.CSharp": "7.17.0.9346",
          "StyleCop.Analyzers": "1.1.118"
        },
        "runtime": {
          "CatLib.Core.dll": {}
        }
      },
      "Microsoft.CodeAnalysis.Analyzers/2.9.4": {},
      "Microsoft.CodeAnalysis.Common/3.3.1": {
        "dependencies": {
          "Microsoft.CodeAnalysis.Analyzers": "2.9.4",
          "System.Collections.Immutable": "1.5.0",
          "System.Memory": "4.5.3",
          "System.Reflection.Metadata": "1.6.0",
          "System.Runtime.CompilerServices.Unsafe": "4.5.2",
          "System.Text.Encoding.CodePages": "4.5.1",
          "System.Threading.Tasks.Extensions": "4.5.3"
        }
      },
      "Microsoft.CodeAnalysis.CSharp/3.3.1": {
        "dependencies": {
          "Microsoft.CodeAnalysis.Common": "3.3.1"
        }
      },
      "Microsoft.CodeAnalysis.FxCopAnalyzers/2.9.6": {
        "dependencies": {
          "Microsoft.CodeAnalysis.VersionCheckAnalyzer": "2.9.6",
          "Microsoft.CodeQuality.Analyzers": "2.9.6",
          "Microsoft.NetCore.Analyzers": "2.9.6",
          "Microsoft.NetFramework.Analyzers": "2.9.6"
        }
      },
      "Microsoft.CodeAnalysis.VersionCheckAnalyzer/2.9.6": {},
      "Microsoft.CodeQuality.Analyzers/2.9.6": {},
      "Microsoft.NetCore.Analyzers/2.9.6": {},
      "Microsoft.NETCore.Platforms/1.1.0": {},
      "Microsoft.NetFramework.Analyzers/2.9.6": {},
      "NETStandard.Library/2.0.3": {
        "dependencies": {
          "Microsoft.NETCore.Platforms": "1.1.0"
        }
      },
      "SonarAnalyzer.CSharp/7.17.0.9346": {},
      "StyleCop.Analyzers/1.1.118": {},
      "System.Buffers/4.4.0": {},
      "System.Collections.Immutable/1.5.0": {},
      "System.Memory/4.5.3": {
        "dependencies": {
          "System.Buffers": "4.4.0",
          "System.Numerics.Vectors": "4.4.0",
          "System.Runtime.CompilerServices.Unsafe": "4.5.2"
        }
      },
      "System.Numerics.Vectors/4.4.0": {},
      "System.Reflection.Metadata/1.6.0": {
        "dependencies": {
          "System.Collections.Immutable": "1.5.0"
        }
      },
      "System.Runtime.CompilerServices.Unsafe/4.5.2": {},
      "System.Text.Encoding.CodePages/4.5.1": {
        "dependencies": {
          "System.Runtime.CompilerServices.Unsafe": "4.5.2"
        }
      },
      "System.Threading.Tasks.Extensions/4.5.3": {
        "dependencies": {
          "System.Runtime.CompilerServices.Unsafe": "4.5.2"
        }
      }
    }
  },
  "libraries": {
    "CatLib.Core/0.2.0-alpha.1+37a93a5": {
      "type": "project",
      "serviceable": false,
      "sha512": ""
    },
    "Microsoft.CodeAnalysis.Analyzers/2.9.4": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-alIJhS0VUg/7x5AsHEoovh/wRZ0RfCSS7k5pDSqpRLTyuMTtRgj6OJJPRApRhJHOGYYsLakf1hKeXFoDwKwNkg==",
      "path": "microsoft.codeanalysis.analyzers/2.9.4",
      "hashPath": "microsoft.codeanalysis.analyzers.2.9.4.nupkg.sha512"
    },
    "Microsoft.CodeAnalysis.Common/3.3.1": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-N5yQdGy+M4kimVG7hwCeGTCfgYjK2o5b/Shumkb/rCC+/SAkvP1HUAYK+vxPFS7dLJNtXLRsmPHKj3fnyNWnrw==",
      "path": "microsoft.codeanalysis.common/3.3.1",
      "hashPath": "microsoft.codeanalysis.common.3.3.1.nupkg.sha512"
    },
    "Microsoft.CodeAnalysis.CSharp/3.3.1": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-WDUIhTHem38H6VJ98x2Ssq0fweakJHnHYl7vbG8ARnsAwLoJKCQCy78EeY1oRrCKG42j0v6JVljKkeqSDA28UA==",
      "path": "microsoft.codeanalysis.csharp/3.3.1",
      "hashPath": "microsoft.codeanalysis.csharp.3.3.1.nupkg.sha512"
    },
    "Microsoft.CodeAnalysis.FxCopAnalyzers/2.9.6": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-GBZV6P8u3uIXYrlapvbpaaaB5LpF3hk+I2ThIcoVyENr8krNOovFyJhi6FQHgnxd0XLPj9J9Nt35iuqwVe/XJw==",
      "path": "microsoft.codeanalysis.fxcopanalyzers/2.9.6",
      "hashPath": "microsoft.codeanalysis.fxcopanalyzers.2.9.6.nupkg.sha512"
    },
    "Microsoft.CodeAnalysis.VersionCheckAnalyzer/2.9.6": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-Q5rRN0+9TJsfsXaGKnzDjGkUZ4Rd8ZKmpSND1j49jsmLacCspp4ZaJ31nJn76B/W0qrb4GkEBxKtj3U9lo2gqg==",
      "path": "microsoft.codeanalysis.versioncheckanalyzer/2.9.6",
      "hashPath": "microsoft.codeanalysis.versioncheckanalyzer.2.9.6.nupkg.sha512"
    },
    "Microsoft.CodeQuality.Analyzers/2.9.6": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-jND04w/FPgfBYKkLLnosmvgHs8NMpMvQ7LQqyiCjMlKOM+MT6edgvTU0vAAowxGuLGceC6pjJm0kUVkG9qT3CQ==",
      "path": "microsoft.codequality.analyzers/2.9.6",
      "hashPath": "microsoft.codequality.analyzers.2.9.6.nupkg.sha512"
    },
    "Microsoft.NetCore.Analyzers/2.9.6": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-YPcQ+gCt66btt9jNHNi4vrRK6AAP7EIO17quwUeHLUw7vhc6q18r2RYVTLKQvOQuOXs1UEYHArENpppwFP4MLA==",
      "path": "microsoft.netcore.analyzers/2.9.6",
      "hashPath": "microsoft.netcore.analyzers.2.9.6.nupkg.sha512"
    },
    "Microsoft.NETCore.Platforms/1.1.0": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A==",
      "path": "microsoft.netcore.platforms/1.1.0",
      "hashPath": "microsoft.netcore.platforms.1.1.0.nupkg.sha512"
    },
    "Microsoft.NetFramework.Analyzers/2.9.6": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-8VyWe53rtUkgJFAkbCZY5KT2t1tEmRrdK1Z+zbyRlzoKVEHyMs0+WNBeJ8d2YB/NjXaYAlaVG2CGZFnQUrwY6A==",
      "path": "microsoft.netframework.analyzers/2.9.6",
      "hashPath": "microsoft.netframework.analyzers.2.9.6.nupkg.sha512"
    },
    "NETStandard.Library/2.0.3": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
      "path": "netstandard.library/2.0.3",
      "hashPath": "netstandard.library.2.0.3.nupkg.sha512"
    },
    "SonarAnalyzer.CSharp/7.17.0.9346": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-Fmap0bvZRojVKRSJj8xS3Bqsltmjy6i3bJF2gXMkuKdtFFJeS546RT75G3YN3IDSygrIEyfQdL+s8ep60vzORQ==",
      "path": "sonaranalyzer.csharp/7.17.0.9346",
      "hashPath": "sonaranalyzer.csharp.7.17.0.9346.nupkg.sha512"
    },
    "StyleCop.Analyzers/1.1.118": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-Onx6ovGSqXSK07n/0eM3ZusiNdB6cIlJdabQhWGgJp3Vooy9AaLS/tigeybOJAobqbtggTamoWndz72JscZBvw==",
      "path": "stylecop.analyzers/1.1.118",
      "hashPath": "stylecop.analyzers.1.1.118.nupkg.sha512"
    },
    "System.Buffers/4.4.0": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-AwarXzzoDwX6BgrhjoJsk6tUezZEozOT5Y9QKF94Gl4JK91I4PIIBkBco9068Y9/Dra8Dkbie99kXB8+1BaYKw==",
      "path": "system.buffers/4.4.0",
      "hashPath": "system.buffers.4.4.0.nupkg.sha512"
    },
    "System.Collections.Immutable/1.5.0": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-EXKiDFsChZW0RjrZ4FYHu9aW6+P4MCgEDCklsVseRfhoO0F+dXeMSsMRAlVXIo06kGJ/zv+2w1a2uc2+kxxSaQ==",
      "path": "system.collections.immutable/1.5.0",
      "hashPath": "system.collections.immutable.1.5.0.nupkg.sha512"
    },
    "System.Memory/4.5.3": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-3oDzvc/zzetpTKWMShs1AADwZjQ/36HnsufHRPcOjyRAAMLDlu2iD33MBI2opxnezcVUtXyqDXXjoFMOU9c7SA==",
      "path": "system.memory/4.5.3",
      "hashPath": "system.memory.4.5.3.nupkg.sha512"
    },
    "System.Numerics.Vectors/4.4.0": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-UiLzLW+Lw6HLed1Hcg+8jSRttrbuXv7DANVj0DkL9g6EnnzbL75EB7EWsw5uRbhxd/4YdG8li5XizGWepmG3PQ==",
      "path": "system.numerics.vectors/4.4.0",
      "hashPath": "system.numerics.vectors.4.4.0.nupkg.sha512"
    },
    "System.Reflection.Metadata/1.6.0": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-COC1aiAJjCoA5GBF+QKL2uLqEBew4JsCkQmoHKbN3TlOZKa2fKLz5CpiRQKDz0RsAOEGsVKqOD5bomsXq/4STQ==",
      "path": "system.reflection.metadata/1.6.0",
      "hashPath": "system.reflection.metadata.1.6.0.nupkg.sha512"
    },
    "System.Runtime.CompilerServices.Unsafe/4.5.2": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-wprSFgext8cwqymChhrBLu62LMg/1u92bU+VOwyfBimSPVFXtsNqEWC92Pf9ofzJFlk4IHmJA75EDJn1b2goAQ==",
      "path": "system.runtime.compilerservices.unsafe/4.5.2",
      "hashPath": "system.runtime.compilerservices.unsafe.4.5.2.nupkg.sha512"
    },
    "System.Text.Encoding.CodePages/4.5.1": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-4J2JQXbftjPMppIHJ7IC+VXQ9XfEagN92vZZNoG12i+zReYlim5dMoXFC1Zzg7tsnKDM7JPo5bYfFK4Jheq44w==",
      "path": "system.text.encoding.codepages/4.5.1",
      "hashPath": "system.text.encoding.codepages.4.5.1.nupkg.sha512"
    },
    "System.Threading.Tasks.Extensions/4.5.3": {
      "type": "package",
      "serviceable": true,
      "sha512": "sha512-+MvhNtcvIbqmhANyKu91jQnvIRVSTiaOiFNfKWwXGHG48YAb4I/TyH8spsySiPYla7gKal5ZnF3teJqZAximyQ==",
      "path": "system.threading.tasks.extensions/4.5.3",
      "hashPath": "system.threading.tasks.extensions.4.5.3.nupkg.sha512"
    }
  }
}

================================================
FILE: .gitattributes
================================================
src/              export-ignore
*.sln             export-ignore
.gitignore        export-ignore
.gitattributes    export-ignore
*.ps1                export-ignore
.github/           export-ignore
.travis.yml        export-ignore
/bucket.json    export-ignore
/README.md  export-ignore
/CHANGELOG.md   export-ignore
/LICENSE        export-ignore

================================================
FILE: .github/ISSUE_TEMPLATE/---bug-report.md
================================================
---
name: "\U0001F41B Bug Report"
about: Report a general framework issue. Please ensure your CatLib version is still
  supported.
title: "[BUG] Add a placeholder for issues title, ex."
labels: Need Review, bug
assignees: yb199478

---

**CatLib version(s) affected**: x.y.z

#### Description

<!-- A clear and concise description of the problem. -->

#### How to reproduce
<!-- Code and/or config needed to reproduce the problem. -->

#### Possible Solution

<!--- Optional: only if you have suggestions on a fix/reason for the bug -->

#### Additional context

<!-- Optional: any other context about the problem: log messages, screenshots, etc. -->


================================================
FILE: .github/ISSUE_TEMPLATE/---documentation-issue.md
================================================
---
name: "\U0001F4DA Documentation Issue"
about: For documentation issues, open a pull request at https://github.com/catlib/catlib-en.io
title: "[Document] Add a placeholder for issues title, ex."
labels: Document, Need Review
assignees: yb199478

---

The CatLib documentation has its own dedicated repository. Please open a pull request at https://github.com/catlib/catlib-en to correct the issue you have found.

Thanks!


================================================
FILE: .github/ISSUE_TEMPLATE/---feature-request.md
================================================
---
name: "\U0001F4A1 Feature Request"
about: Suggest an idea for this project
title: "[Feature] Suggested as the issues title, ex."
labels: Feature, Need Review
assignees: yb199478

---

If you would like to propose new CatLib features, please make a pull request, or open an issue.


================================================
FILE: .github/ISSUE_TEMPLATE/---support-question.md
================================================
---
name: "\U0001F680 Support Question"
about: This repository is only for for questions about using CatLib and its components.
title: "[Question] Add a placeholder for issues title, ex."
labels: Need Review, question
assignees: yb199478

---

> If you need support, please use the document first: http://catlib.io

**CatLib version(s) affected**: x.y.z

#### Description

<!-- A clear and concise description of the problem. -->

#### What's need help

<!-- Briefly and clearly describe what you need to get help. -->


================================================
FILE: .gitignore
================================================
.vs/
src/*/bin/
src/*/obj/
TestResults/
coverage.json
coverage.opencover.xml
.DS_Store
.idea/
*.sln.DotSettings.user


================================================
FILE: .travis.yml
================================================
language: csharp
mono: none
dotnet: 3.0.100

stages:
  - compile
  - test

jobs:
  include:
    - stage: compile
      script:
        - dotnet build -c Release
    - stage: test
      script:
        - dotnet test -c Release -s src/settings.runsettings /p:CollectCoverage=true /p:CoverletOutputFormat=\"json,teamcity,opencover\" /p:CoverletOutput=\"../../coverage/\" /p:Exclude=[*.Tests]* /p:Threshold=90 /p:ThresholdType=line
      after_success:
        - bash <(curl -s https://codecov.io/bash) -f coverage/coverage.opencover.xml -t $CODE_COV_TOKEN

================================================
FILE: CHANGELOG.md
================================================
# Release Notes

## [v2.0.0-alpha.1 (2019-12-04)](https://github.com/CatLib/Core/releases/tag/v2.0.0) 

#### Added

- `Inject` allowed to be set to optional.(#253 )
- `Arr.Test` can get matched value of the first match(#280 )

#### Changed

- Comments translated from Chinese into English(#133 )
- Defined Container.Build as a virtual function(#210 )
- Optimizes the constructor of `MethodContainer`(#218 )
- The default project uses the .net standard 2.0(#225 )
- Rename Util helper class to Helper class Change access level to internal.(#230 )
- `Application.IsRegisted` changed(rename) to `IsRegistered`(#226 ) 
- Use `VariantAttribute` to mark variable types instead of `IVariant`(#232 )
- `Guard` Will be expandable with `Guard.That`(#233 )
- Fixed the problem of container exception stack loss(#234 )
- Adjusted the internal file structure to make it clearer(#236 ).
- Add code analyzers (#206 )
- Refactoring event system (#177 )
- Refactoring `RingBuffer` make it inherit from `Stream`.(#238 )
- Namespace structure adjustment(optimization).(#241 )
- `App` can be extended by `That` (Handler rename to that) and removed `HasHandler` API (#242 )
- Unnecessary inheritance: WrappedStream(#247 )
- Clean up useless comment(#249 ).
- `Guard.Require` can set error messages and internal exceptions(#250).
- Exception class implementation support: SerializationInfo build(#252 ).
- Refactoring unit test, import moq.(#255 )
- `CodeStandardException` replaces to `LogicException`(#257 )
- Exception move to namespace `CatLib.Exception`(#258 )
- `Facade<>.Instance` changed to `Facade<>.That`(#259 )
- `Application.StartProcess` migrate to `StartProcess`(#260 )
- `Arr` optimization, lifting some unnecessary restrictions (#263)
- `Str` optimization, lifting some unnecessary restrictions (#264)
- Refactoring `SortSet`(#265 )
- Removed global params in application constructor. use Application.New() instead.(#267 )
- Containers are no longer thread-safe by default(#270 )

#### Fixed

- Fixed a bug that caused `Arr.Fill` to not work properly under special circumstances. (#255 )

#### Removed

- Removed `ExcludeFromCodeCoverageAttribute` (#229 )
- Removed unnecessary interface design `ISortSet`(#211 ).
- Removed `Version` classes and `Application.Compare` method.(#212).
- Removed `Template`  supported(#213 ).
- Removed `FilterChain` supported(#214 ).
- Removed `Enum` supported(#215 ).
- Removed `IAwait` interface(#217 ).
- Removed `Container.Flash`  api(#219 ).
- Removed `Arr.Flash` method(#220 ).
- Removed `Dict` helper class(#221 ).
- Removed `ThreadStatic` helper class(#223 ).
- Removed `QuickList` supported(#224 ).
- Removed `Storage` supported(#228 )
- Removed `SystemTime` class(#235 ).
- Removed `ICoroutineInit` feature from core library(#243 ).
- Removed the priority attribute, depending on the loading order(#244 ).
- Removed `Util.Encoding` (#245 ).
- Removed `Str.Encoding`(#246 )
- Removed `IServiceProviderType` feature in core library(#246 ).
- Removed unnecessary extension functions(#247 ).
- Removed `PipelineStream` stream.(#256 )
- Removed all `Obsolete` method and clean code.(#261 )
- Removed `App.Version`.(#266 )


================================================
FILE: CatLib.Core.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.28803.202
MinimumVisualStudioVersion = 10.0.40219.1
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CatLib.Core", "src\CatLib.Core\CatLib.Core.csproj", "{C99EA95A-3D04-4588-97E5-D81078EE85BD}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CatLib.Core.Tests", "src\CatLib.Core.Tests\CatLib.Core.Tests.csproj", "{2E89486C-7A92-4C94-8F3E-D8DC1F5C883B}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{C99EA95A-3D04-4588-97E5-D81078EE85BD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{C99EA95A-3D04-4588-97E5-D81078EE85BD}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{C99EA95A-3D04-4588-97E5-D81078EE85BD}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{C99EA95A-3D04-4588-97E5-D81078EE85BD}.Release|Any CPU.Build.0 = Release|Any CPU
		{2E89486C-7A92-4C94-8F3E-D8DC1F5C883B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{2E89486C-7A92-4C94-8F3E-D8DC1F5C883B}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{2E89486C-7A92-4C94-8F3E-D8DC1F5C883B}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{2E89486C-7A92-4C94-8F3E-D8DC1F5C883B}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {BD9525ED-3010-4A67-B726-6FB2960FEC30}
	EndGlobalSection
EndGlobal


================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2017 CatLib

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
<p align="center"><img width="173" height="57" src="https://catlib.io/imgs/logo-txt.png"></p>

<p align="center">
<a href="https://github.com/Catlib/Core/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" title="license-mit" /></a>
<a href="https://www.nuget.org/packages/catlib.core/"><img src="https://badge.fury.io/nu/catlib.core.svg" title="Nuget Version" /></a>
<a href="https://travis-ci.com/CatLib/Core"><img src="https://travis-ci.com/CatLib/Core.svg?branch=master" title="Build status"/></a>
<a href="https://codecov.io/gh/CatLib/Core">
  <img src="https://codecov.io/gh/CatLib/Core/branch/master/graph/badge.svg" alt="Codecov" />
</a>
<a href="https://github.com/CatLib/Core/releases">
  <img src="https://img.shields.io/nuget/dt/CatLib.Core.svg" alt="Downloads" />
</a>
</p>

## About CatLib

`CatLib` is the lightweight dependency injection container and helper functions library. 

- [Service Provider](https://catlib.io/lasted/architecture/service-provider.html)
- [Application](https://catlib.io/lasted/architecture/application.html)
- [IOC Container](https://catlib.io/lasted/architecture/container.html)
- [Facades](https://catlib.io/lasted/architecture/facade.html)

## Install CatLib Core

**Installed with Nuget**

```PM
$ Install-Package CatLib.Core -Version 2.0.0
```

**Installed with [Bucket](https://github.com/getbucket/bucket)**

```shell
$ bucket require catlib/core
```

**Installed with Github Release**

[Download the latest version](https://github.com/CatLib/Core/releases)。

## Learning CatLib

CatLib has the most extensive and thorough [documentation](https://catlib.io), making it a breeze to get started with the framework.

> 需要中文支持? 请访问[CatLib中文文档](https://cn.catlib.io)。

## Contribution

CatLib is still a young framework, and her growth and your contribution are inseparable. If you want to contribute to the project, please refer to: [CatLib Contribution Guide](https://catlib.io/lasted/contribution.html) Your contribution will be included in the list of contributors，Welcome Pull Request!

## License

The open source license used by CatLib is [MIT license](http://opensource.org/licenses/MIT).

## Support

* email: support@catlib.io
* slack: [catlib.slack](https://catlib.slack.com/messages/internals/)


================================================
FILE: bucket.json
================================================
{
	"name": "catlib/core",
	"version": "2.0.0",
	"description": "catlib framework is the lightweight dependency injection container and helper functions library.",
	"keywords": ["framework", "catlib"],
	"license": "MIT",
	"homepage": "https://catlib.io",
	"support": {
		"issues": "https://github.com/CatLib/Core/issues",
		"source": "https://github.com/CatLib/Core"
	},
	"authors": [
		{
			"name": "Meng han Yu",
			"email": "menghanyu1994@gmail.com"
		}
	]
}


================================================
FILE: build.ps1
================================================
param(
[string]$version="master-dev"
)

$dist = ".dist"
$root = (Get-Item -Path ".\").FullName
$publishDir = $root + "\src\CatLib.Core\bin\Release\netstandard2.0\publish"
$version = $version.Trim()
$versionParttern = "^v?(?<master>(?<major>\d{1,5})(?<minor>\.\d+)?(?<patch>\.\d+)?(?<revision>\.\d+)?|master)(?<stability>\-(?:stable|beta|b|RC|alpha|a|patch|pl|p|dev)(?:(?:[.-]?\d+)+)?)?(?<build>\+[0-9A-Za-z\-\.]+)?$"
if(!($version -match $versionParttern))
{
    throw ("Invalid version, must conform to the semver version: " + $version)
}

if($matches["stability"] -eq $null)
{
	$matches["stability"] = "-stable"
}

if($matches["master"] -eq "master")
{
	$matches["major"] = "0"
}

if($matches["minor"] -eq $null)
{
	$matches["minor"] = ".0"
}

if($matches["patch"] -eq $null)
{
	$matches["patch"] = ".0"
}

if($matches["build"] -match "^[0-9a-f]{40}$")
{
	$env:CATLIB_COMMIT_SHA = $matches["build"].substring(1).trim()
    $matches["build"] = $matches["build"].substring(0, 8)
}
elseif($env:CI_COMMIT_SHA -ne $null)
{
	$env:CATLIB_COMMIT_SHA = ($env:CI_COMMIT_SHA).trim()
	$matches["build"] = "+" + $env:CATLIB_COMMIT_SHA.substring(0, 7)
}
else
{
	$env:CATLIB_COMMIT_SHA = (git rev-parse HEAD).trim()
	$matches["build"] = "+" + $env:CATLIB_COMMIT_SHA.substring(0, 7)
}

$major = $matches["major"]
$minor = $matches["minor"]
$assemblyVersion = $major + ".0.0.0"
$versionNormalized = $major + $minor + $matches["patch"] + $matches["revision"] + $matches["stability"] + $matches["build"]

$beginDateTime = ([DateTime] "01/01/2000");
$midnightDateTime = (Get-Date -Hour 0 -Minute 0 -Second 0);

$elapseDay = -1 * (New-TimeSpan -end $beginDateTime).Days
$elapseMidnight = [math]::floor((New-TimeSpan $midnightDateTime -End (Get-Date)).TotalSeconds * 0.5)
$fileVersion = $major + $minor + "." + $elapseDay + "." + $elapseMidnight

dotnet publish src\CatLib.Core\CatLib.Core.csproj -c Release /p:Version=$versionNormalized /p:AssemblyVersion=$assemblyVersion /p:FileVersion=$fileVersion --self-contained false

if($LastExitCode){
	echo "Abnormal. build failded."
	exit(1)
}

if(Test-Path -Path $dist)
{
	Remove-Item $dist -Recurse
}

mkdir $dist
mkdir $dist\netstandard2.0
cp $publishDir\* $dist\netstandard2.0 -Recurse
cp LICENSE $dist
cp CHANGELOG.md $dist
cp README.md $dist
cp bucket.json $dist

$env:CATLIB_PROJECT_VERSION=$versionNormalized.trim()
$env:CATLIB_FILE_VERSION=$fileVersion.trim()
$env:CATLIB_STABILITY=$matches["stability"].substring(1).trim()
$env:CATLIB_MIN_DOTNET_CORE="3.0.0".trim()
$env:CATLIB_PUBLISH_DIR=$publishDir.trim()

echo "CATLIB_COMMIT_SHA $env:CATLIB_COMMIT_SHA"
echo "CATLIB_FILE_VERSION $env:CATLIB_FILE_VERSION"
echo "CATLIB_PROJECT_VERSION $env:CATLIB_PROJECT_VERSION"
echo "CATLIB_STABILITY $env:CATLIB_STABILITY"
echo "CATLIB_MIN_DOTNET_CORE $env:CATLIB_MIN_DOTNET_CORE"
echo "CATLIB_PUBLISH_DIR $env:CATLIB_PUBLISH_DIR"

================================================
FILE: src/CatLib.Core/CatLib/App.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using System;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;

#pragma warning disable CA1030

namespace CatLib
{
    /// <summary>
    /// The <see cref="IApplication"/> static facade.
    /// </summary>
    [ExcludeFromCodeCoverage]
#pragma warning disable S1118
    public abstract class App
#pragma warning restore S1118
    {
        /// <summary>
        /// The <see cref="IApplication"/> instance.
        /// </summary>
        private static IApplication that;

        /// <summary>
        /// Callback when a new <see cref="IApplication"/> instance is created.
        /// </summary>
        public static event Action<IApplication> OnNewApplication
        {
            add
            {
                RaiseOnNewApplication += value;
                if (That != null)
                {
                    value?.Invoke(That);
                }
            }
            remove => RaiseOnNewApplication -= value;
        }

        /// <summary>
        /// Callback when a new <see cref="IApplication"/> instance is created.
        /// </summary>
        private static event Action<IApplication> RaiseOnNewApplication;

        /// <summary>
        /// Gets or Sets the <see cref="IApplication"/> instance.
        /// </summary>
        public static IApplication That
        {
            get
            {
                return that;
            }

            set
            {
                that = value;
                RaiseOnNewApplication?.Invoke(that);
            }
        }

        /// <inheritdoc cref="IApplication.IsMainThread"/>
        public static bool IsMainThread => That.IsMainThread;

        /// <inheritdoc cref="IApplication.DebugLevel"/>
        public static DebugLevel DebugLevel
        {
            get => That.DebugLevel;
            set => That.DebugLevel = value;
        }

        /// <inheritdoc cref="IApplication.Terminate"/>
        public static void Terminate()
        {
            That.Terminate();
        }

        /// <inheritdoc cref="IApplication.Register"/>
        public static void Register(IServiceProvider provider, bool force = false)
        {
            That.Register(provider, force);
        }

        /// <inheritdoc cref="IApplication.IsRegistered"/>
        public static bool IsRegistered(IServiceProvider provider)
        {
            return That.IsRegistered(provider);
        }

        /// <inheritdoc cref="IApplication.GetRuntimeId"/>
        public static long GetRuntimeId()
        {
            return That.GetRuntimeId();
        }

        /// <inheritdoc cref="IContainer.UnbindMethod(object)"/>
        public static void UnbindMethod(object target)
        {
            That.UnbindMethod(target);
        }

        /// <inheritdoc cref="IContainer.Invoke(string, object[])"/>
        public static object Invoke(string method, params object[] userParams)
        {
            return That.Invoke(method, userParams);
        }

        /// <inheritdoc cref="IContainer.OnFindType(Func{string, Type}, int)"/>
        public static IContainer OnFindType(Func<string, Type> func, int priority = int.MaxValue)
        {
            return That.OnFindType(func, priority);
        }

        /// <inheritdoc cref="IContainer.OnRebound(string, Action{object})"/>
        public static IContainer OnRebound(string service, Action<object> callback)
        {
            return That.OnRebound(service, callback);
        }

        /// <inheritdoc cref="IContainer.GetBind"/>
        public static IBindData GetBind(string service)
        {
            return That.GetBind(service);
        }

        /// <inheritdoc cref="ExtendContainer.GetBind{TService}(IContainer)"/>
        public static IBindData GetBind<TService>()
        {
            return That.GetBind<TService>();
        }

        /// <inheritdoc cref="IContainer.HasInstance(string)"/>
        public static bool HasInstance(string service)
        {
            return That.HasInstance(service);
        }

        /// <inheritdoc cref="ExtendContainer.HasInstance{TService}(IContainer)"/>
        public static bool HasInstance<TService>()
        {
#if CATLIB_PERFORMANCE
            return Facade<TService>.HasInstance || Handler.HasInstance<TService>();
#else
            return That.HasInstance<TService>();
#endif
        }

        /// <inheritdoc cref="IContainer.IsResolved(string)"/>
        public static bool IsResolved(string service)
        {
            return That.IsResolved(service);
        }

        /// <inheritdoc cref="ExtendContainer.IsResolved{TService}(IContainer)"/>
        public static bool IsResolved<TService>()
        {
            return That.IsResolved<TService>();
        }

        /// <inheritdoc cref="IContainer.HasBind(string)"/>
        public static bool HasBind(string service)
        {
            return That.HasBind(service);
        }

        /// <inheritdoc cref="ExtendContainer.HasBind{TService}(IContainer)"/>
        public static bool HasBind<TService>()
        {
            return That.HasBind<TService>();
        }

        /// <inheritdoc cref="IContainer.CanMake(string)"/>
        public static bool CanMake(string service)
        {
            return That.CanMake(service);
        }

        /// <inheritdoc cref="ExtendContainer.CanMake{TService}(IContainer)"/>
        public static bool CanMake<TService>()
        {
            return That.CanMake<TService>();
        }

        /// <inheritdoc cref="IContainer.IsStatic(string)"/>
        public static bool IsStatic(string service)
        {
            return That.IsStatic(service);
        }

        /// <inheritdoc cref="ExtendContainer.IsStatic{TService}(IContainer)"/>
        public static bool IsStatic<TService>()
        {
            return That.IsStatic<TService>();
        }

        /// <inheritdoc cref="IContainer.IsAlias(string)"/>
        public static bool IsAlias(string name)
        {
            return That.IsAlias(name);
        }

        /// <inheritdoc cref="ExtendContainer.IsAlias{TService}(IContainer)"/>
        public static bool IsAlias<TService>()
        {
            return That.IsAlias<TService>();
        }

        /// <inheritdoc cref="IContainer.Alias(string, string)"/>
        public static IContainer Alias(string alias, string service)
        {
            return That.Alias(alias, service);
        }

        /// <inheritdoc cref="ExtendContainer.Alias{TAlias, TService}(IContainer)"/>
        public static IContainer Alias<TAlias, TService>()
        {
            return That.Alias<TAlias, TService>();
        }

        /// <inheritdoc cref="IContainer.Extend(string, Func{object, IContainer, object})"/>
        public static void Extend(string service, Func<object, IContainer, object> closure)
        {
            That.Extend(service, closure);
        }

        /// <inheritdoc cref="ExtendContainer.Extend(IContainer, string, Func{object, object})"/>
        public static void Extend(string service, Func<object, object> closure)
        {
            That.Extend(service, closure);
        }

        /// <inheritdoc cref="ExtendContainer.Extend{TConcrete}(IContainer, Func{TConcrete, object})"/>
        public static void Extend<TService, TConcrete>(Func<TConcrete, object> closure)
        {
            That.Extend<TService, TConcrete>(closure);
        }

        /// <inheritdoc cref="ExtendContainer.Extend{TConcrete}(IContainer, Func{TConcrete, IContainer, object})"/>
        public static void Extend<TService, TConcrete>(Func<TConcrete, IContainer, object> closure)
        {
            That.Extend<TService, TConcrete>(closure);
        }

        /// <inheritdoc cref="ExtendContainer.Extend{TService, TConcrete}(IContainer, Func{TConcrete, IContainer, object})"/>
        public static void Extend<TConcrete>(Func<TConcrete, IContainer, object> closure)
        {
            That.Extend(closure);
        }

        /// <inheritdoc cref="ExtendContainer.Extend{TService, TConcrete}(IContainer, Func{TConcrete, object})"/>
        public static void Extend<TConcrete>(Func<TConcrete, object> closure)
        {
            That.Extend(closure);
        }

        /// <inheritdoc cref="ExtendContainer.Bind{TService}(IContainer)"/>
        public static IBindData Bind<TService>()
        {
            return That.Bind<TService>();
        }

        /// <inheritdoc cref="ExtendContainer.Bind{TService, TConcrete}(IContainer)"/>
        public static IBindData Bind<TService, TConcrete>()
        {
            return That.Bind<TService, TConcrete>();
        }

        /// <inheritdoc cref="IContainer.Bind(string, Type, bool)"/>
        public static IBindData Bind(string service, Type concrete, bool isStatic)
        {
            return That.Bind(service, concrete, isStatic);
        }

        /// <inheritdoc cref="IContainer.Bind(string, Func{IContainer, object[], object}, bool)"/>
        public static IBindData Bind(string service, Func<IContainer, object[], object> concrete, bool isStatic)
        {
            return That.Bind(service, concrete, isStatic);
        }

        /// <inheritdoc cref="ExtendContainer.Bind(IContainer, Func{IContainer, object[], object})"/>
        public static IBindData Bind<TService>(Func<IContainer, object[], object> concrete)
        {
            return That.Bind<TService>(concrete);
        }

        /// <inheritdoc cref="ExtendContainer.Bind{TService}(IContainer, Func{object[], object})"/>
        public static IBindData Bind<TService>(Func<object[], object> concrete)
        {
            return That.Bind<TService>(concrete);
        }

        /// <inheritdoc cref="ExtendContainer.Bind{TService}(IContainer, Func{object})"/>
        public static IBindData Bind<TService>(Func<object> concrete)
        {
            return That.Bind<TService>(concrete);
        }

        /// <inheritdoc cref="ExtendContainer.Bind(IContainer, string, Func{IContainer, object[], object})"/>
        public static IBindData Bind(string service, Func<IContainer, object[], object> concrete)
        {
            return That.Bind(service, concrete);
        }

        /// <inheritdoc cref="IContainer.BindIf(string, Func{IContainer, object[], object}, bool, out IBindData)"/>
        public static bool BindIf(string service, Func<IContainer, object[], object> concrete, bool isStatic, out IBindData bindData)
        {
            return That.BindIf(service, concrete, isStatic, out bindData);
        }

        /// <inheritdoc cref="IContainer.BindIf(string, Type, bool, out IBindData)"/>
        public static bool BindIf(string service, Type concrete, bool isStatic, out IBindData bindData)
        {
            return That.BindIf(service, concrete, isStatic, out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.BindIf{TService, TConcrete}(IContainer, out IBindData)"/>
        public static bool BindIf<TService, TConcrete>(out IBindData bindData)
        {
            return That.BindIf<TService, TConcrete>(out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.BindIf{TService}(IContainer, out IBindData)"/>
        public static bool BindIf<TService>(out IBindData bindData)
        {
            return That.BindIf<TService>(out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.BindIf{TService}(IContainer, Func{IContainer, object[], object}, out IBindData)"/>
        public static bool BindIf<TService>(Func<IContainer, object[], object> concrete, out IBindData bindData)
        {
            return That.BindIf<TService>(concrete, out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.BindIf{TService}(IContainer, Func{object[], object}, out IBindData)"/>
        public static bool BindIf<TService>(Func<object[], object> concrete, out IBindData bindData)
        {
            return That.BindIf<TService>(concrete, out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.BindIf{TService}(IContainer, Func{object}, out IBindData)"/>
        public static bool BindIf<TService>(Func<object> concrete, out IBindData bindData)
        {
            return That.BindIf<TService>(concrete, out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.BindIf(IContainer, string, Func{IContainer, object[], object}, out IBindData)"/>
        public static bool BindIf(string service, Func<IContainer, object[], object> concrete, out IBindData bindData)
        {
            return That.BindIf(service, concrete, out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.Singleton{TService, TConcrete}(IContainer)"/>
        public static IBindData Singleton<TService, TConcrete>()
        {
            return That.Singleton<TService, TConcrete>();
        }

        /// <inheritdoc cref="ExtendContainer.Singleton{TService}(IContainer)"/>
        public static IBindData Singleton<TService>()
        {
            return That.Singleton<TService>();
        }

        /// <inheritdoc cref="ExtendContainer.Singleton{TService}(IContainer, Func{IContainer, object[], object})"/>
        public static IBindData Singleton<TService>(Func<IContainer, object[], object> concrete)
        {
            return That.Singleton<TService>(concrete);
        }

        /// <inheritdoc cref="ExtendContainer.Singleton{TService}(IContainer, Func{object[], object})"/>
        public static IBindData Singleton<TService>(Func<object[], object> concrete)
        {
            return That.Singleton<TService>(concrete);
        }

        /// <inheritdoc cref="ExtendContainer.Singleton{TService}(IContainer, Func{object})"/>
        public static IBindData Singleton<TService>(Func<object> concrete)
        {
            return That.Singleton<TService>(concrete);
        }

        /// <inheritdoc cref="ExtendContainer.Singleton(IContainer, string, Func{IContainer, object[], object})"/>
        public static IBindData Singleton(string service, Func<IContainer, object[], object> concrete)
        {
            return That.Singleton(service, concrete);
        }

        /// <inheritdoc cref="ExtendContainer.SingletonIf{TService, TConcrete}(IContainer, out IBindData)"/>
        public static bool SingletonIf<TService, TConcrete>(out IBindData bindData)
        {
            return That.SingletonIf<TService, TConcrete>(out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.SingletonIf{TService}(IContainer, out IBindData)"/>
        public static bool SingletonIf<TService>(out IBindData bindData)
        {
            return That.SingletonIf<TService>(out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.SingletonIf{TService}(IContainer, Func{IContainer, object[], object}, out IBindData)"/>
        public static bool SingletonIf<TService>(Func<IContainer, object[], object> concrete, out IBindData bindData)
        {
            return That.SingletonIf<TService>(concrete, out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.SingletonIf{TService}(IContainer, Func{object[], object}, out IBindData)"/>
        public static bool SingletonIf<TService>(Func<object[], object> concrete, out IBindData bindData)
        {
            return That.SingletonIf<TService>(concrete, out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.SingletonIf{TService}(IContainer, Func{object}, out IBindData)"/>
        public static bool SingletonIf<TService>(Func<object> concrete, out IBindData bindData)
        {
            return That.SingletonIf<TService>(concrete, out bindData);
        }

        /// <inheritdoc cref="ExtendContainer.SingletonIf(IContainer, string, Func{IContainer, object[], object}, out IBindData)"/>
        public static bool SingletonIf(string service, Func<IContainer, object[], object> concrete, out IBindData bindData)
        {
            return That.SingletonIf(service, concrete, out bindData);
        }

        /// <inheritdoc cref="IContainer.BindMethod(string, object, MethodInfo)"/>
        public static IMethodBind BindMethod(string method, object target, MethodInfo call)
        {
            return That.BindMethod(method, target, call);
        }

        /// <inheritdoc cref="ExtendContainer.BindMethod(IContainer, string, object, string)"/>
        public static IMethodBind BindMethod(string method, object target,
            string call = null)
        {
            return That.BindMethod(method, target, call);
        }

        /// <inheritdoc cref="ExtendContainer.BindMethod(IContainer, string, Func{object})"/>
        public static IMethodBind BindMethod(string method, Func<object> callback)
        {
            return That.BindMethod(method, callback);
        }

        /// <inheritdoc cref="ExtendContainer.BindMethod{T1}(IContainer, string, Func{T1, object})"/>
        public static IMethodBind BindMethod<T1>(string method, Func<T1, object> callback)
        {
            return That.BindMethod(method, callback);
        }

        /// <inheritdoc cref="ExtendContainer.BindMethod{T1, T2}(IContainer, string, Func{T1, T2, object})"/>
        public static IMethodBind BindMethod<T1, T2>(string method, Func<T1, T2, object> callback)
        {
            return That.BindMethod(method, callback);
        }

        /// <inheritdoc cref="ExtendContainer.BindMethod{T1, T2, T3}(IContainer, string, Func{T1, T2, T3, object})"/>
        public static IMethodBind BindMethod<T1, T2, T3>(string method, Func<T1, T2, T3, object> callback)
        {
            return That.BindMethod(method, callback);
        }

        /// <inheritdoc cref="ExtendContainer.BindMethod{T1, T2, T3, T4}(IContainer, string, Func{T1, T2, T3, T4, object})"/>
        public static IMethodBind BindMethod<T1, T2, T3, T4>(string method, Func<T1, T2, T3, T4, object> callback)
        {
            return That.BindMethod(method, callback);
        }

        /// <inheritdoc cref="IContainer.Unbind(string)"/>
        public static void Unbind(string service)
        {
            That.Unbind(service);
        }

        /// <inheritdoc cref="ExtendContainer.Unbind{TService}(IContainer)"/>
        public static void Unbind<TService>()
        {
            That.Unbind<TService>();
        }

        /// <inheritdoc cref="IContainer.Tagged(string)"/>
        public static object[] Tagged(string tag)
        {
            return That.Tagged(tag);
        }

        /// <inheritdoc cref="IContainer.Tag(string, string[])"/>
        public static void Tag(string tag, params string[] service)
        {
            That.Tag(tag, service);
        }

        /// <inheritdoc cref="ExtendContainer.Tag{TService}(IContainer, string)"/>
        public static void Tag<TService>(string tag)
        {
            That.Tag<TService>(tag);
        }

        /// <inheritdoc cref="IContainer.Instance(string, object)"/>
        public static object Instance(string service, object instance)
        {
            return That.Instance(service, instance);
        }

        /// <inheritdoc cref="ExtendContainer.Instance{TService}(IContainer, object)"/>
        public static void Instance<TService>(object instance)
        {
            That.Instance<TService>(instance);
        }

        /// <inheritdoc cref="IContainer.Release(object)"/>
        public static bool Release(string service)
        {
            return That.Release(service);
        }

        /// <inheritdoc cref="ExtendContainer.Release{TService}(IContainer)"/>
        public static bool Release<TService>()
        {
            return That.Release<TService>();
        }

        /// <inheritdoc cref="ExtendContainer.Release(IContainer, ref object[], bool)"/>
        public static bool Release(ref object[] instances, bool reverse = true)
        {
            return That.Release(ref instances, reverse);
        }

        /// <inheritdoc cref="IContainer.Call(object, MethodInfo, object[])"/>
        public static object Call(object instance, MethodInfo methodInfo, params object[] userParams)
        {
            return That.Call(instance, methodInfo, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Call(IContainer, object, string, object[])"/>
        public static object Call(object instance, string method, params object[] userParams)
        {
            return That.Call(instance, method, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Call{T1}(IContainer, Action{T1}, object[])"/>
        public static void Call<T1>(Action<T1> method, params object[] userParams)
        {
            That.Call(method, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Call{T1, T2}(IContainer, Action{T1, T2}, object[])"/>
        public static void Call<T1, T2>(Action<T1, T2> method, params object[] userParams)
        {
            That.Call(method, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Call{T1, T2, T3}(IContainer, Action{T1, T2, T3}, object[])"/>
        public static void Call<T1, T2, T3>(Action<T1, T2, T3> method, params object[] userParams)
        {
            That.Call(method, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Call{T1, T2, T3, T4}(IContainer, Action{T1, T2, T3, T4}, object[])"/>
        public static void Call<T1, T2, T3, T4>(Action<T1, T2, T3, T4> method, params object[] userParams)
        {
            That.Call(method, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Wrap{T1}(IContainer, Action{T1}, object[])"/>
        public static Action Wrap<T1>(Action<T1> method, params object[] userParams)
        {
            return That.Wrap(method, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Wrap{T1, T2}(IContainer, Action{T1, T2}, object[])"/>
        public static Action Wrap<T1, T2>(Action<T1, T2> method, params object[] userParams)
        {
            return That.Wrap(method, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Wrap{T1, T2, T3}(IContainer, Action{T1, T2, T3}, object[])"/>
        public static Action Wrap<T1, T2, T3>(Action<T1, T2, T3> method, params object[] userParams)
        {
            return That.Wrap(method, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Wrap{T1, T2, T3, T4}(IContainer, Action{T1, T2, T3, T4}, object[])"/>
        public static Action Wrap<T1, T2, T3, T4>(Action<T1, T2, T3, T4> method, params object[] userParams)
        {
            return That.Wrap(method, userParams);
        }

        /// <inheritdoc cref="IContainer.Make(string, object[])"/>
        public static object Make(string service, params object[] userParams)
        {
            return That.Make(service, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Make{TService}(IContainer, object[])"/>
        public static TService Make<TService>(params object[] userParams)
        {
#if CATLIB_PERFORMANCE
            return Facade<TService>.Make(userParams);
#else
            return That.Make<TService>(userParams);
#endif
        }

        /// <inheritdoc cref="ExtendContainer.Make(IContainer, Type, object[])"/>
        public static object Make(Type type, params object[] userParams)
        {
            return That.Make(type, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Factory(IContainer, string, object[])"/>
        public static Func<object> Factory(string service, params object[] userParams)
        {
            return That.Factory(service, userParams);
        }

        /// <inheritdoc cref="ExtendContainer.Factory{TService}(IContainer, object[])"/>
        public static Func<TService> Factory<TService>(params object[] userParams)
        {
            return That.Factory<TService>(userParams);
        }

        /// <inheritdoc cref="IContainer.OnRelease(Action{IBindData, object})"/>
        public static IContainer OnRelease(Action<IBindData, object> action)
        {
            return That.OnRelease(action);
        }

        /// <inheritdoc cref="ExtendContainer.OnRelease(IContainer, Action{object})"/>
        public static IContainer OnRelease(Action<object> callback)
        {
            return That.OnRelease(callback);
        }

        /// <inheritdoc cref="ExtendContainer.OnRelease{T}(IContainer, Action{T})"/>
        public static IContainer OnRelease<TWhere>(Action<TWhere> closure)
        {
            return That.OnRelease(closure);
        }

        /// <inheritdoc cref="ExtendContainer.OnRelease{T}(IContainer, Action{IBindData, T})"/>
        public static IContainer OnRelease<TWhere>(Action<IBindData, TWhere> closure)
        {
            return That.OnRelease(closure);
        }

        /// <inheritdoc cref="IContainer.OnResolving(Action{IBindData, object})"/>
        public static IContainer OnResolving(Action<IBindData, object> closure)
        {
            return That.OnResolving(closure);
        }

        /// <inheritdoc cref="ExtendContainer.OnRelease(IContainer, Action{object})"/>
        public static IContainer OnResolving(Action<object> callback)
        {
            return That.OnResolving(callback);
        }

        /// <inheritdoc cref="ExtendContainer.OnResolving{T}(IContainer, Action{T})"/>
        public static IContainer OnResolving<TWhere>(Action<TWhere> closure)
        {
            return That.OnResolving(closure);
        }

        /// <inheritdoc cref="ExtendContainer.OnResolving{T}(IContainer, Action{IBindData, T})"/>
        public static IContainer OnResolving<TWhere>(Action<IBindData, TWhere> closure)
        {
            return That.OnResolving(closure);
        }

        /// <inheritdoc cref="IContainer.OnAfterResolving(Action{IBindData, object})"/>
        public static IContainer OnAfterResolving(Action<IBindData, object> closure)
        {
            return That.OnAfterResolving(closure);
        }

        /// <inheritdoc cref="ExtendContainer.OnAfterResolving(IContainer, Action{object})"/>
        public static IContainer OnAfterResolving(Action<object> closure)
        {
            return That.OnAfterResolving(closure);
        }

        /// <inheritdoc cref="ExtendContainer.OnAfterResolving{T}(IContainer, Action{T})"/>
        public static IContainer OnAfterResolving<TWhere>(Action<TWhere> closure)
        {
            return That.OnAfterResolving(closure);
        }

        /// <inheritdoc cref="ExtendContainer.OnAfterResolving{T}(IContainer, Action{IBindData, T})"/>
        public static IContainer OnAfterResolving<TWhere>(Action<IBindData, TWhere> closure)
        {
            return That.OnAfterResolving(closure);
        }

        /// <inheritdoc cref="ExtendContainer.Watch{TService}(IContainer, Action)"/>
        public static void Watch<TService>(Action method)
        {
            That.Watch<TService>(method);
        }

        /// <inheritdoc cref="ExtendContainer.Watch{TService}(IContainer, Action{TService})"/>
        public static void Watch<TService>(Action<TService> method)
        {
            That.Watch(method);
        }

        /// <inheritdoc cref="IContainer.Type2Service(Type)"/>
        public static string Type2Service(Type type)
        {
            return That.Type2Service(type);
        }

        /// <inheritdoc cref="ExtendContainer.Type2Service{TService}(IContainer)"/>
        public static string Type2Service<TService>()
        {
            return That.Type2Service<TService>();
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Application.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using CatLib.EventDispatcher;
using CatLib.Exception;
using CatLib.Util;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Threading;

namespace CatLib
{
    /// <summary>
    /// The CatLib <see cref="Application"/> instance.
    /// </summary>
    public class Application : Container.Container, IApplication
    {
        private static string version;
        private readonly IList<IServiceProvider> loadedProviders;
        private readonly int mainThreadId;
        private readonly IDictionary<Type, string> dispatchMapping;
        private bool bootstrapped;
        private bool inited;
        private bool registering;
        private long incrementId;
        private DebugLevel debugLevel;
        private IEventDispatcher dispatcher;

        /// <summary>
        /// Initializes a new instance of the <see cref="Application"/> class.
        /// </summary>
        /// <param name="global">True if sets the instance to <see cref="App"/> facade.</param>
        public Application()
        {
            loadedProviders = new List<IServiceProvider>();

            mainThreadId = Thread.CurrentThread.ManagedThreadId;
            RegisterBaseBindings();

            dispatchMapping = new Dictionary<Type, string>()
            {
                { typeof(AfterBootEventArgs), ApplicationEvents.OnAfterBoot },
                { typeof(AfterInitEventArgs), ApplicationEvents.OnAfterInit },
                { typeof(AfterTerminateEventArgs), ApplicationEvents.OnAfterTerminate },
                { typeof(BeforeBootEventArgs), ApplicationEvents.OnBeforeBoot },
                { typeof(BeforeInitEventArgs), ApplicationEvents.OnBeforeInit },
                { typeof(BeforeTerminateEventArgs), ApplicationEvents.OnBeforeTerminate },
                { typeof(BootingEventArgs), ApplicationEvents.OnBooting },
                { typeof(InitProviderEventArgs), ApplicationEvents.OnInitProvider },
                { typeof(RegisterProviderEventArgs), ApplicationEvents.OnRegisterProvider },
                { typeof(StartCompletedEventArgs), ApplicationEvents.OnStartCompleted },
            };

            // We use closures to save the current context state
            // Do not change to: OnFindType(Type.GetType) This
            // causes the active assembly to be not the expected scope.
            OnFindType(finder => { return Type.GetType(finder); });

            DebugLevel = DebugLevel.Production;
            Process = StartProcess.Construct;
        }

        /// <summary>
        /// Gets the CatLib <see cref="Application"/> version.
        /// </summary>
        public static string Version => version ?? (version = FileVersionInfo
                       .GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion);

        /// <summary>
        /// Gets indicates the application startup process.
        /// </summary>
        public StartProcess Process { get; private set; }

        /// <inheritdoc />
        public bool IsMainThread => mainThreadId == Thread.CurrentThread.ManagedThreadId;

        /// <inheritdoc />
        public DebugLevel DebugLevel
        {
            get => debugLevel;
            set
            {
                debugLevel = value;
                this.Instance<DebugLevel>(debugLevel);
            }
        }

        /// <inheritdoc cref="Application(bool)"/>
        /// <returns>The CatLib <see cref="Application"/> instance.</returns>
        public static Application New(bool global = true)
        {
            var application = new Application();
            if (global)
            {
                App.That = application;
            }

            return application;
        }

        /// <summary>
        /// Sets the event dispatcher.
        /// </summary>
        /// <param name="dispatcher">The event dispatcher instance.</param>
        public void SetDispatcher(IEventDispatcher dispatcher)
        {
            this.dispatcher = dispatcher;
            this.Instance<IEventDispatcher>(dispatcher);
        }

        /// <inheritdoc />
        public IEventDispatcher GetDispatcher()
        {
            return dispatcher;
        }

        /// <inheritdoc />
        public virtual void Terminate()
        {
            Process = StartProcess.Terminate;
            Raise(new BeforeTerminateEventArgs(this));
            Process = StartProcess.Terminating;
            Flush();
            if (App.That == this)
            {
                App.That = null;
            }

            Process = StartProcess.Terminated;
            Raise(new AfterTerminateEventArgs(this));
        }

        /// <summary>
        /// Bootstrap the given array of bootstrap classes.
        /// </summary>
        /// <param name="bootstraps">The given bootstrap classes.</param>
        public virtual void Bootstrap(params IBootstrap[] bootstraps)
        {
            Guard.Requires<ArgumentNullException>(bootstraps != null);

            if (bootstrapped || Process != StartProcess.Construct)
            {
                throw new LogicException($"Cannot repeatedly trigger the {nameof(Bootstrap)}()");
            }

            Process = StartProcess.Bootstrap;
            bootstraps = Raise(new BeforeBootEventArgs(bootstraps, this))
                            .GetBootstraps();
            Process = StartProcess.Bootstrapping;

            var existed = new HashSet<IBootstrap>();

            foreach (var bootstrap in bootstraps)
            {
                if (bootstrap == null)
                {
                    continue;
                }

                if (existed.Contains(bootstrap))
                {
                    throw new LogicException($"The bootstrap already exists : {bootstrap}");
                }

                existed.Add(bootstrap);

                var skipped = Raise(new BootingEventArgs(bootstrap, this))
                                .IsSkip;
                if (!skipped)
                {
                    bootstrap.Bootstrap();
                }
            }

            Process = StartProcess.Bootstraped;
            bootstrapped = true;
            Raise(new AfterBootEventArgs(this));
        }

        /// <summary>
        /// Init all of the registered service provider.
        /// </summary>
        public virtual void Init()
        {
            if (!bootstrapped)
            {
                throw new LogicException($"You must call {nameof(Bootstrap)}() first.");
            }

            if (inited || Process != StartProcess.Bootstraped)
            {
                throw new LogicException($"Cannot repeatedly trigger the {nameof(Init)}()");
            }

            Process = StartProcess.Init;
            Raise(new BeforeInitEventArgs(this));
            Process = StartProcess.Initing;

            foreach (var provider in loadedProviders)
            {
                InitProvider(provider);
            }

            inited = true;
            Process = StartProcess.Inited;
            Raise(new AfterInitEventArgs(this));

            Process = StartProcess.Running;
            Raise(new StartCompletedEventArgs(this));
        }

        /// <inheritdoc />
        public virtual void Register(IServiceProvider provider, bool force = false)
        {
            Guard.Requires<ArgumentNullException>(provider != null, $"Parameter \"{nameof(provider)}\" can not be null.");

            if (IsRegistered(provider))
            {
                if (!force)
                {
                    throw new LogicException($"Provider [{provider.GetType()}] is already register.");
                }

                loadedProviders.Remove(provider);
            }

            if (Process == StartProcess.Initing)
            {
                throw new LogicException($"Unable to add service provider during {nameof(StartProcess.Initing)}");
            }

            if (Process > StartProcess.Running)
            {
                throw new LogicException($"Unable to {nameof(Terminate)} in-process registration service provider");
            }

            if (provider is ServiceProvider baseProvider)
            {
                baseProvider.SetApplication(this);
            }

            var skipped = Raise(new RegisterProviderEventArgs(provider, this))
                            .IsSkip;
            if (skipped)
            {
                return;
            }

            try
            {
                registering = true;
                provider.Register();
            }
            finally
            {
                registering = false;
            }

            loadedProviders.Add(provider);

            if (inited)
            {
                InitProvider(provider);
            }
        }

        /// <inheritdoc />
        public bool IsRegistered(IServiceProvider provider)
        {
            Guard.Requires<ArgumentNullException>(provider != null);
            return loadedProviders.Contains(provider);
        }

        /// <inheritdoc />
        public long GetRuntimeId()
        {
            return Interlocked.Increment(ref incrementId);
        }

        /// <summary>
        /// Initialize the specified service provider.
        /// </summary>
        /// <param name="provider">The specified service provider.</param>
        protected virtual void InitProvider(IServiceProvider provider)
        {
            Raise(new InitProviderEventArgs(provider, this));
            provider.Init();
        }

        /// <inheritdoc />
        protected override void GuardConstruct(string method)
        {
            if (registering)
            {
                throw new LogicException(
                    $"It is not allowed to make services or dependency injection in the {nameof(Register)} process, method:{method}");
            }

            base.GuardConstruct(method);
        }

        private void RegisterBaseBindings()
        {
            this.Singleton<IApplication>(() => this).Alias<Application>().Alias<IContainer>();
            SetDispatcher(new EventDispatcher.EventDispatcher());
        }

        private T Raise<T>(T args)
            where T : EventArgs
        {
            if (!dispatchMapping.TryGetValue(args.GetType(), out string eventName))
            {
                throw new AssertException($"Assertion error: Undefined event {args}");
            }

            if (dispatcher == null)
            {
                return args;
            }

            dispatcher.Raise(eventName, this, args);
            return args;
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/DebugLevel.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// Indicates the framework debug level.
    /// </summary>
    public enum DebugLevel
    {
        /// <summary>
        /// Production environment
        /// </summary>
        Production,

        /// <summary>
        /// Between the production environment and the developer environment
        /// </summary>
        Staging,

        /// <summary>
        /// Development environment
        /// </summary>
        Development,
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/AfterBootEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// Indicates that the bootstrap has been booted.
    /// </summary>
    public class AfterBootEventArgs : ApplicationEventArgs
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="AfterBootEventArgs"/> class.
        /// </summary>
        /// <param name="application">The application instance.</param>
        public AfterBootEventArgs(IApplication application)
            : base(application)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/AfterInitEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// Indicates that all the <see cref="IServiceProvider.Init"/> has been called.
    /// </summary>
    public class AfterInitEventArgs : ApplicationEventArgs
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="AfterInitEventArgs"/> class.
        /// </summary>
        /// <param name="application">The application instance.</param>
        public AfterInitEventArgs(IApplication application)
            : base(application)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/AfterTerminateEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// Indicates that the framework will terminate.
    /// </summary>
    public class AfterTerminateEventArgs : ApplicationEventArgs
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="AfterTerminateEventArgs"/> class.
        /// </summary>
        /// <param name="application">The terminate application instance.</param>
        public AfterTerminateEventArgs(IApplication application)
            : base(application)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/ApplicationEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;

namespace CatLib
{
    /// <summary>
    /// Represents an application event.
    /// </summary>
    public class ApplicationEventArgs : EventArgs
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ApplicationEventArgs"/> class.
        /// </summary>
        /// <param name="application">The application instance.</param>
        public ApplicationEventArgs(IApplication application)
        {
            Application = application;
        }

        /// <summary>
        /// Gets the application instance.
        /// </summary>
        public IApplication Application { get; private set; }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/ApplicationEvents.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// Contains all events dispatched by an Application.
    /// </summary>
    public static class ApplicationEvents
    {
        /// <summary>
        /// Before the <see cref="Application.Bootstrap"/> call.
        /// </summary>
        public static readonly string OnBeforeBoot = $"{BaseEventArgs}.OnBeforeBoot";

        /// <summary>
        /// When the <see cref="Application.Bootstrap"/> call is in progress.
        /// </summary>
        public static readonly string OnBooting = $"{BaseEventArgs}.BootingEventArgs";

        /// <summary>
        /// After the <see cref="Application.Bootstrap"/> called.
        /// </summary>
        public static readonly string OnAfterBoot = $"{BaseEventArgs}.AfterBootEventArgs";

        /// <summary>
        /// When registering for a service provider.
        /// </summary>
        public static readonly string OnRegisterProvider = $"{BaseEventArgs}.RegisterProviderEventArgs";

        /// <summary>
        /// Before the <see cref="Application.Init"/> call.
        /// </summary>
        public static readonly string OnBeforeInit = $"{BaseEventArgs}.BeforeInitEventArgs";

        /// <summary>
        /// Before the <see cref="IServiceProvider.Init"/> call.
        /// </summary>
        public static readonly string OnInitProvider = $"{BaseEventArgs}.InitProviderEventArgs";

        /// <summary>
        /// After the <see cref="Application.Init"/> called.
        /// </summary>
        public static readonly string OnAfterInit = $"{BaseEventArgs}.AfterInitEventArgs";

        /// <summary>
        /// When the framework is started.
        /// </summary>
        public static readonly string OnStartCompleted = $"{BaseEventArgs}.StartCompletedEventArgs";

        /// <summary>
        /// Before the <see cref="Application.Terminate"/> call.
        /// </summary>
        public static readonly string OnBeforeTerminate = $"{BaseEventArgs}.BeforeTerminateEventArgs";

        /// <summary>
        /// After the <see cref="Application.Terminate"/> called.
        /// </summary>
        public static readonly string OnAfterTerminate = $"{BaseEventArgs}.AfterTerminateEventArgs";

        private const string BaseEventArgs = "EventArgs.ApplicationEventArgs";
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/BeforeBootEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// It indicates that the bootstrap will be bootstrapped.
    /// </summary>
    public class BeforeBootEventArgs : ApplicationEventArgs
    {
        private IBootstrap[] bootstraps;

        /// <summary>
        /// Initializes a new instance of the <see cref="BeforeBootEventArgs"/> class.
        /// </summary>
        /// <param name="bootstraps">An array of the bootstrap list.</param>
        /// <param name="application">The application instance.</param>
        public BeforeBootEventArgs(IBootstrap[] bootstraps, IApplication application)
            : base(application)
        {
            this.bootstraps = bootstraps;
        }

        /// <summary>
        /// Gets an array of bootstrap will be bootstrapped.
        /// </summary>
        /// <returns>Returns an array of bootstraps.</returns>
        public IBootstrap[] GetBootstraps()
        {
            return bootstraps;
        }

        /// <summary>
        /// Sets the bootstrap will replace the old boot list.
        /// </summary>
        /// <param name="bootstraps">New bootstrap list.</param>
        public void SetBootstraps(IBootstrap[] bootstraps)
        {
            this.bootstraps = bootstraps;
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/BeforeInitEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// It indicates that the <see cref="IServiceProvider.Init"/> method will be called.
    /// </summary>
    public class BeforeInitEventArgs : ApplicationEventArgs
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="BeforeInitEventArgs"/> class.
        /// </summary>
        /// <param name="bootstraps">An array of the bootstrap list.</param>
        /// <param name="application">The application instance.</param>
        public BeforeInitEventArgs(IApplication application)
            : base(application)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/BeforeTerminateEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// Indicates that the framework will terminate.
    /// </summary>
    public class BeforeTerminateEventArgs : ApplicationEventArgs
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="BeforeTerminateEventArgs"/> class.
        /// </summary>
        /// <param name="application">The terminate application instance.</param>
        public BeforeTerminateEventArgs(IApplication application)
            : base(application)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/BootingEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.EventDispatcher;

namespace CatLib
{
    /// <summary>
    /// Indicates a boot class that is booting.
    /// </summary>
    public class BootingEventArgs : ApplicationEventArgs, IStoppableEvent
    {
        private readonly IBootstrap bootstrap;

        /// <summary>
        /// Initializes a new instance of the <see cref="BootingEventArgs"/> class.
        /// </summary>
        /// <param name="bootstrap">The boot class that is booting.</param>
        /// <param name="application">The application instance.</param>
        public BootingEventArgs(IBootstrap bootstrap, IApplication application)
            : base(application)
        {
            IsSkip = false;
            this.bootstrap = bootstrap;
        }

        /// <summary>
        /// Gets a value indicating whether the boot class is skip booting.
        /// </summary>
        public bool IsSkip { get; private set; }

        /// <inheritdoc />
        public bool IsPropagationStopped => IsSkip;

        /// <summary>
        /// Gets the a boot class that is booting.
        /// </summary>
        /// <returns>Return the boot class.</returns>
        public IBootstrap GetBootstrap()
        {
            return bootstrap;
        }

        /// <summary>
        /// Disable the boot class.
        /// </summary>
        public void Skip()
        {
            IsSkip = true;
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/InitProviderEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// Indicates a service provider that will inited.
    /// </summary>
    public class InitProviderEventArgs : ApplicationEventArgs
    {
        private readonly IServiceProvider provider;

        /// <summary>
        /// Initializes a new instance of the <see cref="InitProviderEventArgs"/> class.
        /// </summary>
        /// <param name="provider">The service provider class that will inited.</param>
        /// <param name="application">The application instance.</param>
        public InitProviderEventArgs(IServiceProvider provider, IApplication application)
            : base(application)
        {
            this.provider = provider;
        }

        /// <summary>
        /// Gets the a service provider class that will inited.
        /// </summary>
        /// <returns>Return the service provider class.</returns>
        public IServiceProvider GetServiceProvider()
        {
            return provider;
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/RegisterProviderEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.EventDispatcher;

namespace CatLib
{
    /// <summary>
    /// Indicates a service provider that will register.
    /// </summary>
    public class RegisterProviderEventArgs : ApplicationEventArgs, IStoppableEvent
    {
        private readonly IServiceProvider provider;

        /// <summary>
        /// Initializes a new instance of the <see cref="RegisterProviderEventArgs"/> class.
        /// </summary>
        /// <param name="provider">The service provider class that will register.</param>
        /// <param name="application">The application instance.</param>
        public RegisterProviderEventArgs(IServiceProvider provider, IApplication application)
            : base(application)
        {
            IsSkip = false;
            this.provider = provider;
        }

        /// <summary>
        /// Gets a value indicating whether the service provider is skip register.
        /// </summary>
        public bool IsSkip { get; private set; }

        /// <inheritdoc />
        public bool IsPropagationStopped => IsSkip;

        /// <summary>
        /// Gets the a service provider class that will register.
        /// </summary>
        /// <returns>Return the service provider class.</returns>
        public IServiceProvider GetServiceProvider()
        {
            return provider;
        }

        /// <summary>
        /// Skip the register service provider.
        /// </summary>
        public void Skip()
        {
            IsSkip = true;
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Events/StartCompletedEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// Indicates that the framework ready.
    /// </summary>
    public class StartCompletedEventArgs : ApplicationEventArgs
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="StartCompletedEventArgs"/> class.
        /// </summary>
        /// <param name="application">The application instance.</param>
        public StartCompletedEventArgs(IApplication application)
            : base(application)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/Facade.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

#pragma warning disable CA1000
#pragma warning disable S2743
#pragma warning disable S1118

using CatLib.Container;

namespace CatLib
{
    /// <summary>
    /// <see cref="Facade{TService}"/> is the abstract implemented by all facade classes.
    /// </summary>
    /// <typeparam name="TService">The service type.</typeparam>
    /// <remarks>
    /// <code>public class FileSystem : Facade&gt;IFileSystem&lt;{ }</code>
    /// </remarks>
    public abstract class Facade<TService>
    {
        private static readonly string Service;
        private static TService that;
        private static IBindData binder;
        private static bool inited;
        private static bool released;

        /// <summary>
        /// Initializes static members of the <see cref="Facade{TService}"/> class.
        /// </summary>
#pragma warning disable S3963
        static Facade()
#pragma warning restore S3963
        {
            Service = App.Type2Service(typeof(TService));
            App.OnNewApplication += app =>
            {
                that = default;
                binder = null;
                inited = false;
                released = false;
            };
        }

        /// <inheritdoc cref="that"/>
        public static TService That => HasInstance ? that : Resolve();

        /// <summary>
        /// Gets a value indicating whether the resolved instance is exists in the facade.
        /// <para>If it is a non-static binding then return forever false.</para>
        /// </summary>
        internal static bool HasInstance => binder != null && binder.IsStatic && !released && that != null;

        /// <summary>
        /// Resolve the object instance.
        /// </summary>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The resolved object.</returns>
        internal static TService Make(params object[] userParams)
        {
            return HasInstance ? that : Resolve(userParams);
        }

        /// <inheritdoc cref="Make"/>
        private static TService Resolve(params object[] userParams)
        {
            released = false;

            if (!inited && (App.IsResolved(Service) || App.CanMake(Service)))
            {
                App.Watch<TService>(ServiceRebound);
                inited = true;
            }
            else if (binder != null && !binder.IsStatic)
            {
                // If it has been initialized, the binder has been initialized.
                // Then judging in advance can optimize performance without
                // going through a hash lookup.
                return Build(userParams);
            }

            var newBinder = App.GetBind(Service);
            if (newBinder == null || !newBinder.IsStatic)
            {
                binder = newBinder;
                return Build(userParams);
            }

            Rebind(newBinder);
            return that = Build(userParams);
        }

        /// <summary>
        /// When the resolved object is released.
        /// </summary>
        /// <param name="oldBinder">The old bind data with resolved object.</param>
        /// <param name="instance">The ignored parameter.</param>
        private static void OnRelease(IBindData oldBinder, object instance)
        {
            if (oldBinder != binder)
            {
                return;
            }

            that = default;
            released = true;
        }

        /// <summary>
        /// When the resolved object is rebound.
        /// </summary>
        /// <param name="newService">The new resolved object.</param>
        private static void ServiceRebound(TService newService)
        {
            var newBinder = App.GetBind(Service);
            Rebind(newBinder);
            that = (newBinder == null || !newBinder.IsStatic) ? default : newService;
        }

        /// <summary>
        /// Rebinding the bound data to given binder.
        /// </summary>
        /// <param name="newBinder">The new binder.</param>
        private static void Rebind(IBindData newBinder)
        {
            if (newBinder != null && binder != newBinder && newBinder.IsStatic)
            {
                newBinder.OnRelease(OnRelease);
            }

            binder = newBinder;
        }

        /// <summary>
        /// Resolve facade object from the container.
        /// </summary>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The resolved object.</returns>
        private static TService Build(params object[] userParams)
        {
            return (TService)App.Make(Service, userParams);
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/IApplication.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this sender code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using CatLib.EventDispatcher;

namespace CatLib
{
    /// <summary>
    /// <see cref="IApplication"/> is the interface implemented by all application classes.
    /// </summary>
    public interface IApplication : IContainer
    {
        /// <summary>
        /// Gets a value indicating whether true if we're on the main thread.
        /// </summary>
        bool IsMainThread { get; }

        /// <summary>
        /// Gets or sets the debug level.
        /// </summary>
        DebugLevel DebugLevel { get; set; }

        /// <summary>
        /// Gets the event dispatcher.
        /// </summary>
        /// <returns>Returns event dispatcher instance, null if the dispatcher not found.</returns>
        IEventDispatcher GetDispatcher();

        /// <summary>
        /// Register a service provider with the application.
        /// </summary>
        /// <param name="provider">The service provider.</param>
        /// <param name="force">True if the force register.</param>
        void Register(IServiceProvider provider, bool force = false);

        /// <summary>
        /// Checks whether the given service provider is registered.
        /// </summary>
        /// <param name="provider">The service provider.</param>
        /// <returns>True if the service provider is registered.</returns>
        bool IsRegistered(IServiceProvider provider);

        /// <summary>
        /// Gets the unique runtime id.
        /// </summary>
        /// <returns>The unique runtime id.</returns>
        long GetRuntimeId();

        /// <summary>
        /// Terminates the <see cref="IApplication"/>.
        /// </summary>
        void Terminate();
    }
}


================================================
FILE: src/CatLib.Core/CatLib/IBootstrap.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// <see cref="IBootstrap"/> is the interface implemented by all bootstrap classes.
    /// </summary>
    public interface IBootstrap
    {
        /// <summary>
        /// Bootstrap the framework.
        /// </summary>
        void Bootstrap();
    }
}


================================================
FILE: src/CatLib.Core/CatLib/IServiceProvider.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// <see cref="IServiceProvider"/> is the interface implemented by all service provider classes.
    /// </summary>
    public interface IServiceProvider
    {
        /// <summary>
        /// Initialize the application's service providers.
        /// </summary>
        void Init();

        /// <summary>
        /// Register any application services.
        /// </summary>
        void Register();
    }
}


================================================
FILE: src/CatLib.Core/CatLib/ServiceProvider.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System.Diagnostics.CodeAnalysis;

namespace CatLib
{
    /// <summary>
    /// <see cref="ServiceProvider"/> is default service provider class
    /// for all concrete ServiceProvider classes.
    /// </summary>
    [ExcludeFromCodeCoverage]
    public abstract class ServiceProvider : IServiceProvider
    {
        /// <summary>
        /// Gets application instance.
        /// </summary>
        protected IApplication App { get; private set; }

        /// <inheritdoc />
        public virtual void Init()
        {
        }

        /// <inheritdoc />
        public virtual void Register()
        {
        }

        internal void SetApplication(IApplication application)
        {
            App = application;
        }
    }
}


================================================
FILE: src/CatLib.Core/CatLib/StartProcess.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib
{
    /// <summary>
    /// The framework start process type.
    /// </summary>
    public enum StartProcess
    {
        /// <summary>
        /// When you create a new <see cref="Application"/>,
        /// you are in the <see cref="Construct"/> phase.
        /// </summary>
        Construct = 0,

        /// <summary>
        /// Before the <see cref="Application.Bootstrap"/> call.
        /// </summary>
        Bootstrap = 1,

        /// <summary>
        /// When during <see cref="Application.Bootstrap"/> execution,
        /// you are in the <see cref="Bootstrapping"/> phase.
        /// </summary>
        Bootstrapping = 2,

        /// <summary>
        /// After the <see cref="Application.Bootstrap"/> called.
        /// </summary>
        Bootstraped = 3,

        /// <summary>
        /// Before the <see cref="Application.Init"/> call.
        /// </summary>
        Init = 4,

        /// <summary>
        /// When during <see cref="Application.Init"/> execution,
        /// you are in the <see cref="Initing"/> phase.
        /// </summary>
        Initing = 5,

        /// <summary>
        /// After the <see cref="Application.Init"/> called.
        /// </summary>
        Inited = 6,

        /// <summary>
        /// When the framework running.
        /// </summary>
        Running = 7,

        /// <summary>
        /// Before the <see cref="Application.Terminate"/> call.
        /// </summary>
        Terminate = 8,

        /// <summary>
        /// When during <see cref="Application.Terminate"/> execution,
        /// you are in the <see cref="Terminating"/> phase.
        /// </summary>
        Terminating = 9,

        /// <summary>
        /// After the <see cref="Application.Terminate"/> called.
        /// All resources are destroyed.
        /// </summary>
        Terminated = 10,
    }
}


================================================
FILE: src/CatLib.Core/CatLib.Core.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <Version>2.0.0</Version>
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
    <Authors>CatLib</Authors>
    <Company>CatLib</Company>
    <Description>CatLib lightweight dependency injection container</Description>
    <PackageLicenseExpression>MIT</PackageLicenseExpression>
    <PackageProjectUrl>https://github.com/CatLib/Core</PackageProjectUrl>
    <RepositoryUrl>https://github.com/CatLib/Core</RepositoryUrl>
    <RepositoryType>github</RepositoryType>
    <PackageTags>catlib, ioc, inject, framework</PackageTags>
  </PropertyGroup>

</Project>


================================================
FILE: src/CatLib.Core/Container/BindData.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using CatLib.Util;
using System;
using System.Collections.Generic;
using CatLibContainer = CatLib.Container.Container;

namespace CatLib.Container
{
    /// <inheritdoc cref="IBindData"/>
    public sealed class BindData : Bindable<IBindData>, IBindData
    {
        /// <summary>
        /// The local resolving callbacks.
        /// </summary>
        private List<Action<IBindData, object>> resolving;

        /// <summary>
        /// The local after resolving callbacks.
        /// </summary>
        private List<Action<IBindData, object>> afterResolving;

        /// <summary>
        /// The local release callbacks.
        /// </summary>
        private List<Action<IBindData, object>> release;

        /// <summary>
        /// Initializes a new instance of the <see cref="BindData"/> class.
        /// </summary>
        /// <param name="container">The container instance.</param>
        /// <param name="service">The service name.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <param name="isStatic">Whether the service is singleton(static).</param>
        public BindData(CatLibContainer container, string service, Func<IContainer, object[], object> concrete, bool isStatic)
            : base(container, service)
        {
            Concrete = concrete;
            IsStatic = isStatic;
        }

        /// <inheritdoc />
        public Func<IContainer, object[], object> Concrete { get; }

        /// <inheritdoc />
        public bool IsStatic { get; }

        /// <inheritdoc />
        public IBindData Alias(string alias)
        {
            AssertDestroyed();
            Guard.ParameterNotNull(alias, nameof(alias));

            Container.Alias(alias, Service);
            return this;
        }

        /// <inheritdoc />
        public IBindData Tag(string tag)
        {
            AssertDestroyed();
            Guard.ParameterNotNull(tag, nameof(tag));

            Container.Tag(tag, Service);
            return this;
        }

        /// <inheritdoc />
        public IBindData OnResolving(Action<IBindData, object> closure)
        {
            AddClosure(closure, ref resolving);
            return this;
        }

        /// <inheritdoc />
        public IBindData OnAfterResolving(Action<IBindData, object> closure)
        {
            AddClosure(closure, ref afterResolving);
            return this;
        }

        /// <inheritdoc />
        public IBindData OnRelease(Action<IBindData, object> closure)
        {
            if (!IsStatic)
            {
                throw new LogicException(
                    $"Service [{Service}] is not Singleton(Static) Bind , Can not call {nameof(OnRelease)}().");
            }

            AddClosure(closure, ref release);
            return this;
        }

        internal object TriggerResolving(object instance)
        {
            return CatLibContainer.Trigger(this, instance, resolving);
        }

        internal object TriggerAfterResolving(object instance)
        {
            return CatLibContainer.Trigger(this, instance, afterResolving);
        }

        internal object TriggerRelease(object instance)
        {
            return CatLibContainer.Trigger(this, instance, release);
        }

        /// <inheritdoc />
        protected override void ReleaseBind()
        {
            ((CatLibContainer)Container).Unbind(this);
        }

        private void AddClosure(Action<IBindData, object> closure, ref List<Action<IBindData, object>> collection)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            AssertDestroyed();

            if (collection == null)
            {
                collection = new List<Action<IBindData, object>>();
            }

            collection.Add(closure);
        }
    }
}


================================================
FILE: src/CatLib.Core/Container/BindDataExtension.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Util;
using System;

namespace CatLib.Container
{
    /// <summary>
    /// An extension function for <see cref="BindData"/>.
    /// </summary>
    public static class BindDataExtension
    {
        /// <inheritdoc cref="IBindData.Alias"/>
        /// <typeparam name="TAlias">The type convert to alias name.</typeparam>
        public static IBindData Alias<TAlias>(this IBindData bindData)
        {
            return bindData.Alias(bindData.Container.Type2Service(typeof(TAlias)));
        }

        /// <inheritdoc cref="IBindData.OnResolving"/>
        public static IBindData OnResolving(this IBindData bindData, Action closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnResolving((_, instance) =>
            {
                closure();
            });
        }

        /// <inheritdoc cref="IBindData.OnResolving"/>
        public static IBindData OnResolving(this IBindData bindData, Action<object> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnResolving((_, instance) =>
            {
                closure(instance);
            });
        }

        /// <inheritdoc cref="IBindData.OnResolving"/>
        /// <typeparam name="T">The type of resolve instance.</typeparam>
        public static IBindData OnResolving<T>(this IBindData bindData, Action<T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnResolving((_, instance) =>
            {
                if (instance is T)
                {
                    closure((T)instance);
                }
            });
        }

        /// <inheritdoc cref="OnResolving{T}(IBindData, Action{T})"/>
        public static IBindData OnResolving<T>(this IBindData bindData, Action<IBindData, T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnResolving((bind, instance) =>
            {
                if (instance is T)
                {
                    closure(bind, (T)instance);
                }
            });
        }

        /// <inheritdoc cref="IBindData.OnAfterResolving"/>
        public static IBindData OnAfterResolving(this IBindData bindData, Action closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnAfterResolving((_, instance) =>
            {
                closure();
            });
        }

        /// <inheritdoc cref="IBindData.OnAfterResolving"/>
        public static IBindData OnAfterResolving(this IBindData bindData, Action<object> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnAfterResolving((_, instance) =>
            {
                closure(instance);
            });
        }

        /// <inheritdoc cref="IBindData.OnAfterResolving"/>
        /// <typeparam name="T">The type of resolve instance.</typeparam>
        public static IBindData OnAfterResolving<T>(this IBindData bindData, Action<T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnAfterResolving((_, instance) =>
            {
                if (instance is T)
                {
                    closure((T)instance);
                }
            });
        }

        /// <inheritdoc cref="OnAfterResolving{T}(IBindData, Action{T})"/>
        public static IBindData OnAfterResolving<T>(this IBindData bindData, Action<IBindData, T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnAfterResolving((bind, instance) =>
            {
                if (instance is T)
                {
                    closure(bind, (T)instance);
                }
            });
        }

        /// <inheritdoc cref="IBindData.OnRelease"/>
        public static IBindData OnRelease(this IBindData bindData, Action closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnRelease((_, __) =>
            {
                closure();
            });
        }

        /// <inheritdoc cref="IBindData.OnRelease"/>
        public static IBindData OnRelease(this IBindData bindData, Action<object> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnRelease((_, instance) =>
            {
                closure(instance);
            });
        }

        /// <inheritdoc cref="IBindData.OnRelease"/>
        /// <typeparam name="T">The type of release instance.</typeparam>
        public static IBindData OnRelease<T>(this IBindData bindData, Action<T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnRelease((_, instance) =>
            {
                if (instance is T)
                {
                    closure((T)instance);
                }
            });
        }

        /// <inheritdoc cref="OnRelease{T}(IBindData, Action{T})"/>
        public static IBindData OnRelease<T>(this IBindData bindData, Action<IBindData, T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return bindData.OnRelease((bind, instance) =>
            {
                if (instance is T)
                {
                    closure(bind, (T)instance);
                }
            });
        }
    }
}


================================================
FILE: src/CatLib.Core/Container/Bindable.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using CatLib.Util;
using System;
using System.Collections.Generic;

namespace CatLib.Container
{
    /// <summary>
    /// The bindable data indicates relational data related to the specified service.
    /// </summary>
    public abstract class Bindable : IBindable
    {
        private readonly Container container;
        private Dictionary<string, string> contextual;
        private Dictionary<string, Func<object>> contextualClosure;
        private bool isDestroy;

        /// <summary>
        /// Initializes a new instance of the <see cref="Bindable"/> class.
        /// </summary>
        /// <param name="container">The container instance.</param>
        /// <param name="service">The service name.</param>
        protected Bindable(Container container, string service)
        {
            this.container = container;
            Service = service;
            isDestroy = false;
        }

        /// <inheritdoc />
        public string Service { get; }

        /// <summary>
        /// Gets the container to which the service belongs.
        /// </summary>
        public IContainer Container => container;

        /// <inheritdoc />
        public void Unbind()
        {
            isDestroy = true;
            ReleaseBind();
        }

        /// <summary>
        /// Add the context with service.
        /// </summary>
        /// <param name="needs">Demand specified service.</param>
        /// <param name="given">Given speified service or alias.</param>
        internal void AddContextual(string needs, string given)
        {
            AssertDestroyed();
            if (contextual == null)
            {
                contextual = new Dictionary<string, string>();
            }

            if (contextual.ContainsKey(needs)
                || (contextualClosure != null && contextualClosure.ContainsKey(needs)))
            {
                throw new LogicException($"Needs [{needs}] is already exist.");
            }

            contextual.Add(needs, given);
        }

        /// <inheritdoc cref="AddContextual(string, string)"/>
        /// <param name="given">The closure return the given service instance.</param>
        internal void AddContextual(string needs, Func<object> given)
        {
            AssertDestroyed();
            if (contextualClosure == null)
            {
                contextualClosure = new Dictionary<string, Func<object>>();
            }

            if (contextualClosure.ContainsKey(needs)
                || (contextual != null && contextual.ContainsKey(needs)))
            {
                throw new LogicException($"Needs [{needs}] is already exist.");
            }

            contextualClosure.Add(needs, given);
        }

        /// <summary>
        /// Get the demand context of the service.
        /// </summary>
        /// <param name="needs">The demand service.</param>
        /// <returns>The given service or alias.</returns>
        internal string GetContextual(string needs)
        {
            if (contextual == null)
            {
                return null;
            }

            return contextual.TryGetValue(needs, out string contextualNeeds) ? contextualNeeds : null;
        }

        /// <inheritdoc cref="GetContextual"/>
        /// <returns>The closure return the given service instance.</returns>
        internal Func<object> GetContextualClosure(string needs)
        {
            if (contextualClosure == null)
            {
                return null;
            }

            return contextualClosure.TryGetValue(needs, out Func<object> closure) ? closure : null;
        }

        /// <inheritdoc cref="Unbind"/>
        protected abstract void ReleaseBind();

        /// <summary>
        /// Verify that the current instance i has been released.
        /// </summary>
        protected void AssertDestroyed()
        {
            if (isDestroy)
            {
                throw new LogicException("The current instance is destroyed.");
            }
        }
    }

#pragma warning disable SA1402

    /// <inheritdoc />
    public abstract class Bindable<TReturn> : Bindable, IBindable<TReturn>
        where TReturn : class, IBindable<TReturn>
    {
        /// <summary>
        /// Indicates the given relationship in the context.
        /// </summary>
        private GivenData<TReturn> given;

        /// <summary>
        /// Initializes a new instance of the <see cref="Bindable{TReturn}"/> class.
        /// </summary>
        /// <param name="container">The container instance.</param>
        /// <param name="service">The service name.</param>
        protected Bindable(Container container, string service)
            : base(container, service)
        {
        }

        /// <inheritdoc />
        public IGivenData<TReturn> Needs(string service)
        {
            Guard.ParameterNotNull(service, nameof(service));

            AssertDestroyed();
            if (given == null)
            {
                given = new GivenData<TReturn>((Container)Container, this);
            }

            given.Needs(service);
            return given;
        }

        /// <inheritdoc />
        public IGivenData<TReturn> Needs<TService>()
        {
            return Needs(Container.Type2Service(typeof(TService)));
        }
    }
}


================================================
FILE: src/CatLib.Core/Container/Container.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using CatLib.Util;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.ExceptionServices;
using System.Text;
using SException = System.Exception;

namespace CatLib.Container
{
    /// <summary>
    /// The catlib ioc container implemented.
    /// </summary>
    public class Container : IContainer
    {
        /// <summary>
        /// Characters not allowed in the service name.
        /// </summary>
        private static readonly char[] ServiceBanChars = { '@', ':', '$' };

        /// <summary>
        /// The container's bindings.
        /// </summary>
        private readonly Dictionary<string, BindData> bindings;

        /// <summary>
        /// The container's singleton(static) instances.
        /// </summary>
        private readonly Dictionary<string, object> instances;

        /// <summary>
        /// The container's singleton instances inverse index mapping.
        /// </summary>
        private readonly Dictionary<object, string> instancesReverse;

        /// <summary>
        /// The registered aliases with service.
        /// </summary>
        private readonly Dictionary<string, string> aliases;

        /// <summary>
        /// The registered aliases with service. inverse index mapping.
        /// </summary>
        private readonly Dictionary<string, List<string>> aliasesReverse;

        /// <summary>
        /// All of the registered tags.
        /// </summary>
        private readonly Dictionary<string, List<string>> tags;

        /// <summary>
        /// All of the global resolving callbacks.
        /// </summary>
        private readonly List<Action<IBindData, object>> resolving;

        /// <summary>
        /// All of the global after resolving callbacks.
        /// </summary>
        private readonly List<Action<IBindData, object>> afterResloving;

        /// <summary>
        /// All of the global release callbacks.
        /// </summary>
        private readonly List<Action<IBindData, object>> release;

        /// <summary>
        /// The extension closures for services.
        /// </summary>
        private readonly Dictionary<string, List<Func<object, IContainer, object>>> extenders;

        /// <summary>
        /// The type finder convert a string to a service type.
        /// </summary>
        private readonly SortSet<Func<string, Type>, int> findType;

        /// <summary>
        /// The cache that has been type found.
        /// </summary>
        private readonly Dictionary<string, Type> findTypeCache;

        /// <summary>
        /// An hash set of the service that have been resolved.
        /// </summary>
        private readonly HashSet<string> resolved;

        /// <summary>
        /// The singleton service build timing.
        /// </summary>
        private readonly SortSet<string, int> instanceTiming;

        /// <summary>
        /// All of the registered rebound callbacks.
        /// </summary>
        private readonly Dictionary<string, List<Action<object>>> rebound;

        /// <summary>
        /// The method ioc container.
        /// </summary>
        private readonly MethodContainer methodContainer;

        /// <summary>
        /// Represents a skipped object to skip some dependency injection.
        /// </summary>
        private readonly object skipped;

        /// <summary>
        /// Whether the container is flushing.
        /// </summary>
        private bool flushing;

        /// <summary>
        /// The unique Id is used to mark the global build order.
        /// </summary>
        private int instanceId;

        /// <summary>
        /// Initializes a new instance of the <see cref="Container"/> class.
        /// </summary>
        /// <param name="prime">The estimated number of services.</param>
        public Container(int prime = 64)
        {
            prime = Math.Max(8, prime);
            tags = new Dictionary<string, List<string>>((int)(prime * 0.25));
            aliases = new Dictionary<string, string>(prime * 4);
            aliasesReverse = new Dictionary<string, List<string>>(prime * 4);
            instances = new Dictionary<string, object>(prime * 4);
            instancesReverse = new Dictionary<object, string>(prime * 4);
            bindings = new Dictionary<string, BindData>(prime * 4);
            resolving = new List<Action<IBindData, object>>((int)(prime * 0.25));
            afterResloving = new List<Action<IBindData, object>>((int)(prime * 0.25));
            release = new List<Action<IBindData, object>>((int)(prime * 0.25));
            extenders = new Dictionary<string, List<Func<object, IContainer, object>>>((int)(prime * 0.25));
            resolved = new HashSet<string>();
            findType = new SortSet<Func<string, Type>, int>();
            findTypeCache = new Dictionary<string, Type>(prime * 4);
            rebound = new Dictionary<string, List<Action<object>>>(prime);
            instanceTiming = new SortSet<string, int>();
            BuildStack = new Stack<string>(32);
            UserParamsStack = new Stack<object[]>(32);
            skipped = new object();
            methodContainer = new MethodContainer(this);
            flushing = false;
            instanceId = 0;
        }

        /// <summary>
        /// Gets the stack of concretions currently being built.
        /// </summary>
        protected Stack<string> BuildStack { get; }

        /// <summary>
        /// Gets the stack of the user params being built.
        /// </summary>
        protected Stack<object[]> UserParamsStack { get; }

        /// <inheritdoc />
        public object this[string service]
        {
            get => Make(service);
            set
            {
                GetBind(service)?.Unbind();
                Bind(service, (container, args) => value, false);
            }
        }

        /// <inheritdoc />
        public void Tag(string tag, params string[] services)
        {
            Guard.ParameterNotNull(tag, nameof(tag));
            GuardFlushing();

            if (!tags.TryGetValue(tag, out List<string> collection))
            {
                tags[tag] = collection = new List<string>();
            }

            foreach (var service in services ?? Array.Empty<string>())
            {
                if (string.IsNullOrEmpty(service))
                {
                    continue;
                }

                collection.Add(service);
            }
        }

        /// <inheritdoc />
        public object[] Tagged(string tag)
        {
            Guard.ParameterNotNull(tag, nameof(tag));

            if (!tags.TryGetValue(tag, out List<string> services))
            {
                throw new LogicException($"Tag \"{tag}\" is not exist.");
            }

            return Arr.Map(services, (service) => Make(service));
        }

        /// <inheritdoc />
        public IBindData GetBind(string service)
        {
            if (string.IsNullOrEmpty(service))
            {
                return null;
            }

            service = AliasToService(service);
            return bindings.TryGetValue(service, out BindData bindData)
                ? bindData : null;
        }

        /// <inheritdoc />
        public bool HasBind(string service)
        {
            return GetBind(service) != null;
        }

        /// <inheritdoc />
        public bool HasInstance(string service)
        {
            Guard.ParameterNotNull(service, nameof(service));

            service = AliasToService(service);
            return instances.ContainsKey(service);
        }

        /// <inheritdoc />
        public bool IsResolved(string service)
        {
            Guard.ParameterNotNull(service, nameof(service));

            service = AliasToService(service);
            return resolved.Contains(service) || instances.ContainsKey(service);
        }

        /// <inheritdoc />
        public bool CanMake(string service)
        {
            Guard.ParameterNotNull(service, nameof(service));

            service = AliasToService(service);
            if (HasBind(service) || HasInstance(service))
            {
                return true;
            }

            var type = SpeculatedServiceType(service);
            return !IsBasicType(type) && !IsUnableType(type);
        }

        /// <inheritdoc />
        public bool IsStatic(string service)
        {
            var bind = GetBind(service);
            return bind != null && bind.IsStatic;
        }

        /// <inheritdoc />
        public bool IsAlias(string name)
        {
            name = FormatService(name);
            return aliases.ContainsKey(name);
        }

        /// <inheritdoc />
        public IContainer Alias(string alias, string service)
        {
            Guard.ParameterNotNull(alias, nameof(alias));
            Guard.ParameterNotNull(service, nameof(service));

            if (alias == service)
            {
                throw new LogicException($"Alias is same as service: \"{alias}\".");
            }

            GuardFlushing();

            alias = FormatService(alias);
            service = AliasToService(service);

            if (aliases.ContainsKey(alias))
            {
                throw new LogicException($"Alias \"{alias}\" is already exists.");
            }

            if (bindings.ContainsKey(alias))
            {
                throw new LogicException($"Alias \"{alias}\" has been used for service name.");
            }

            if (!bindings.ContainsKey(service) && !instances.ContainsKey(service))
            {
                throw new LogicException(
                    $"You must {nameof(Bind)}() or {nameof(Instance)}() serivce before and you be able to called {nameof(Alias)}().");
            }

            aliases.Add(alias, service);

            if (!aliasesReverse.TryGetValue(service, out List<string> collection))
            {
                aliasesReverse[service] = collection = new List<string>();
            }

            collection.Add(alias);

            return this;
        }

        /// <inheritdoc />
        public bool BindIf(string service, Func<IContainer, object[], object> concrete, bool isStatic, out IBindData bindData)
        {
            var bind = GetBind(service);
            if (bind == null && (HasInstance(service) || IsAlias(service)))
            {
                bindData = null;
                return false;
            }

            bindData = bind ?? Bind(service, concrete, isStatic);
            return bind == null;
        }

        /// <inheritdoc />
        public bool BindIf(string service, Type concrete, bool isStatic, out IBindData bindData)
        {
            if (!IsUnableType(concrete))
            {
                service = FormatService(service);
                return BindIf(service, WrapperTypeBuilder(service, concrete), isStatic, out bindData);
            }

            bindData = null;
            return false;
        }

        /// <inheritdoc />
        public IBindData Bind(string service, Type concrete, bool isStatic)
        {
            Guard.Requires<ArgumentNullException>(concrete != null, $"Parameter {nameof(concrete)} can not be null.");

            if (IsUnableType(concrete))
            {
                throw new LogicException($"Type \"{concrete}\" can not bind. please check if there is a list of types that cannot be built.");
            }

            service = FormatService(service);
            return Bind(service, WrapperTypeBuilder(service, concrete), isStatic);
        }

        /// <inheritdoc />
        public IBindData Bind(string service, Func<IContainer, object[], object> concrete, bool isStatic)
        {
            Guard.ParameterNotNull(service, nameof(service));
            Guard.ParameterNotNull(concrete, nameof(concrete));
            GuardServiceName(service);
            GuardFlushing();

            service = FormatService(service);
            if (bindings.ContainsKey(service))
            {
                throw new LogicException($"Bind [{service}] already exists.");
            }

            if (instances.ContainsKey(service))
            {
                throw new LogicException($"Instances [{service}] is already exists.");
            }

            if (aliases.ContainsKey(service))
            {
                throw new LogicException($"Aliase [{service}] is already exists.");
            }

            var bindData = new BindData(this, service, concrete, isStatic);
            bindings.Add(service, bindData);

            if (!IsResolved(service))
            {
                return bindData;
            }

            if (isStatic)
            {
                // If it is "static" then solve this service directly
                // The process of staticizing the service triggers TriggerOnRebound
                Make(service);
            }
            else
            {
                TriggerOnRebound(service);
            }

            return bindData;
        }

        /// <inheritdoc />
        public IMethodBind BindMethod(string method, object target, MethodInfo called)
        {
            GuardFlushing();
            GuardMethodName(method);
            return methodContainer.Bind(method, target, called);
        }

        /// <inheritdoc />
        public void UnbindMethod(object target)
        {
            methodContainer.Unbind(target);
        }

        /// <inheritdoc />
        public object Invoke(string method, params object[] userParams)
        {
            GuardConstruct(nameof(Invoke));
            return methodContainer.Invoke(method, userParams);
        }

        /// <inheritdoc />
        public object Call(object target, MethodInfo methodInfo, params object[] userParams)
        {
            Guard.Requires<ArgumentNullException>(methodInfo != null);
            if (!methodInfo.IsStatic)
            {
                Guard.Requires<ArgumentNullException>(target != null);
            }

            GuardConstruct(nameof(Call));

            var parameter = methodInfo.GetParameters();
            var bindData = GetBindFillable(target != null ? Type2Service(target.GetType()) : null);
            userParams = GetDependencies(bindData, parameter, userParams) ?? Array.Empty<object>();
            return methodInfo.Invoke(target, userParams);
        }

        /// <inheritdoc />
        public object Make(string service, params object[] userParams)
        {
            GuardConstruct(nameof(Make));
            return Resolve(service, userParams);
        }

        /// <inheritdoc />
        public void Extend(string service, Func<object, IContainer, object> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            GuardFlushing();

            service = string.IsNullOrEmpty(service) ? string.Empty : AliasToService(service);

            if (!string.IsNullOrEmpty(service) && instances.TryGetValue(service, out object instance))
            {
                // If the instance already exists then apply the extension.
                // Extensions will no longer be added to the permanent extension list.
                var old = instance;
                instances[service] = instance = closure(instance, this);

                if (!old.Equals(instance))
                {
                    instancesReverse.Remove(old);
                    instancesReverse.Add(instance, service);
                }

                TriggerOnRebound(service, instance);
                return;
            }

            if (!extenders.TryGetValue(service, out List<Func<object, IContainer, object>> extender))
            {
                extenders[service] = extender = new List<Func<object, IContainer, object>>();
            }

            extender.Add(closure);

            if (!string.IsNullOrEmpty(service) && IsResolved(service))
            {
                TriggerOnRebound(service);
            }
        }

        /// <summary>
        /// Remove all extensions for the specified service.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        public void ClearExtenders(string service)
        {
            GuardFlushing();
            service = AliasToService(service);
            extenders.Remove(service);

            if (!IsResolved(service))
            {
                return;
            }

            Release(service);
            TriggerOnRebound(service);
        }

        /// <inheritdoc />
        public object Instance(string service, object instance)
        {
            Guard.ParameterNotNull(service, nameof(service));
            GuardFlushing();
            GuardServiceName(service);

            service = AliasToService(service);

            var bindData = GetBind(service);
            if (bindData != null)
            {
                if (!bindData.IsStatic)
                {
                    throw new LogicException($"Service [{service}] is not Singleton(Static) Bind.");
                }
            }
            else
            {
                bindData = MakeEmptyBindData(service);
            }

            instance = TriggerOnResolving((BindData)bindData, instance);

            if (instance != null
                && instancesReverse.TryGetValue(instance, out string realService)
                && realService != service)
            {
                throw new LogicException($"The instance has been registered as a singleton in {realService}");
            }

            var isResolved = IsResolved(service);
            Release(service);

            instances.Add(service, instance);

            if (instance != null)
            {
                instancesReverse.Add(instance, service);
            }

            if (!instanceTiming.Contains(service))
            {
                instanceTiming.Add(service, instanceId++);
            }

            if (isResolved)
            {
                TriggerOnRebound(service, instance);
            }

            return instance;
        }

        /// <inheritdoc />
        public bool Release(object mixed)
        {
            if (mixed == null)
            {
                return false;
            }

            string service;
            object instance = null;
            if (!(mixed is string))
            {
                service = GetServiceWithInstanceObject(mixed);
            }
            else
            {
                service = AliasToService(mixed.ToString());
                if (!instances.TryGetValue(service, out instance))
                {
                    // Prevent the use of a string as a service name.
                    service = GetServiceWithInstanceObject(mixed);
                }
            }

            if (instance == null &&
                (string.IsNullOrEmpty(service) || !instances.TryGetValue(service, out instance)))
            {
                return false;
            }

            var bindData = GetBindFillable(service);
            bindData.TriggerRelease(instance);
            TriggerOnRelease(bindData, instance);

            if (instance != null)
            {
                DisposeInstance(instance);
                instancesReverse.Remove(instance);
            }

            instances.Remove(service);

            if (!HasOnReboundCallbacks(service))
            {
                instanceTiming.Remove(service);
            }

            return true;
        }

        /// <inheritdoc />
        public IContainer OnFindType(Func<string, Type> func, int priority = int.MaxValue)
        {
            Guard.Requires<ArgumentNullException>(func != null);
            GuardFlushing();
            findType.Add(func, priority);
            return this;
        }

        /// <inheritdoc />
        public IContainer OnRelease(Action<IBindData, object> closure)
        {
            AddClosure(closure, release);
            return this;
        }

        /// <inheritdoc />
        public IContainer OnResolving(Action<IBindData, object> closure)
        {
            AddClosure(closure, resolving);
            return this;
        }

        /// <inheritdoc />
        public IContainer OnAfterResolving(Action<IBindData, object> closure)
        {
            AddClosure(closure, afterResloving);
            return this;
        }

        /// <inheritdoc />
        public IContainer OnRebound(string service, Action<object> callback)
        {
            Guard.Requires<ArgumentNullException>(callback != null);
            GuardFlushing();

            service = AliasToService(service);
            if (!IsResolved(service) && !CanMake(service))
            {
                throw new LogicException(
                    $"If you want use Rebound(Watch) , please {nameof(Bind)} or {nameof(Instance)} service first.");
            }

            if (!rebound.TryGetValue(service, out List<Action<object>> list))
            {
                rebound[service] = list = new List<Action<object>>();
            }

            list.Add(callback);
            return this;
        }

        /// <inheritdoc />
        public void Unbind(string service)
        {
            service = AliasToService(service);
            var bind = GetBind(service);
            bind?.Unbind();
        }

        /// <inheritdoc />
        public virtual void Flush()
        {
            try
            {
                flushing = true;
                foreach (var service in instanceTiming.GetIterator(false))
                {
                    Release(service);
                }

                Guard.Requires<AssertException>(instances.Count <= 0);

                tags.Clear();
                aliases.Clear();
                aliasesReverse.Clear();
                instances.Clear();
                bindings.Clear();
                resolving.Clear();
                release.Clear();
                extenders.Clear();
                resolved.Clear();
                findType.Clear();
                findTypeCache.Clear();
                BuildStack.Clear();
                UserParamsStack.Clear();
                rebound.Clear();
                methodContainer.Flush();
                instanceTiming.Clear();
                instanceId = 0;
            }
            finally
            {
                flushing = false;
            }
        }

        /// <inheritdoc />
        public string Type2Service(Type type)
        {
            return type.ToString();
        }

        /// <summary>
        /// Trigger all callbacks in specified list.
        /// </summary>
        /// <param name="bindData">The bind data for <see cref="Make"/> service.</param>
        /// <param name="instance">The service instance.</param>
        /// <param name="list">The specified list.</param>
        /// <returns>The decorated service instance.</returns>
        internal static object Trigger(IBindData bindData, object instance, List<Action<IBindData, object>> list)
        {
            if (list == null)
            {
                return instance;
            }

            foreach (var closure in list)
            {
                closure(bindData, instance);
            }

            return instance;
        }

        /// <summary>
        /// Unbind the service from the container.
        /// </summary>
        /// <param name="bindable">The bindable instance.</param>
        internal void Unbind(IBindable bindable)
        {
            GuardFlushing();
            Release(bindable.Service);
            if (aliasesReverse.TryGetValue(bindable.Service, out List<string> serviceList))
            {
                foreach (var alias in serviceList)
                {
                    aliases.Remove(alias);
                }

                aliasesReverse.Remove(bindable.Service);
            }

            bindings.Remove(bindable.Service);
        }

        /// <summary>
        /// Gets an array of resolved instances for dependent parameters.
        /// </summary>
        /// <param name="makeServiceBindData">The bind data for <see cref="Make"/> service.</param>
        /// <param name="baseParams">The dependent parameters array for <see cref="Make"/> service.</param>
        /// <param name="userParams">An array for the user parameter.</param>
        /// <returns>An array of resolved instances for dependent parameters.</returns>
        protected internal virtual object[] GetDependencies(Bindable makeServiceBindData, ParameterInfo[] baseParams, object[] userParams)
        {
            if (baseParams.Length <= 0)
            {
                return Array.Empty<object>();
            }

            var results = new object[baseParams.Length];

            // Gets a parameter matcher for filtering parameters
            var matcher = GetParamsMatcher(ref userParams);

            for (var i = 0; i < baseParams.Length; i++)
            {
                var baseParam = baseParams[i];

                // Parameter matching is used to match the parameters.
                // The parameter matchers are the first to perform because their
                // matching accuracy is the most accurate.
                var param = matcher?.Invoke(baseParam);

                // When the container finds that the developer uses object or object[] as
                // the dependency parameter type, we try to compact inject the user parameters.
                param = param ?? GetCompactInjectUserParams(baseParam, ref userParams);

                // Select the appropriate parameters from the user parameters and inject
                // them in the relative order.
                param = param ?? GetDependenciesFromUserParams(baseParam, ref userParams);

                string needService = null;

                if (param == null)
                {
                    // Try to generate the required parameters through the dependency
                    // injection container.
                    needService = GetParamNeedsService(baseParam);

                    if (baseParam.ParameterType.IsClass
                        || baseParam.ParameterType.IsInterface)
                    {
                        param = ResloveClass(makeServiceBindData, needService, baseParam);
                    }
                    else
                    {
                        param = ResolvePrimitive(makeServiceBindData, needService, baseParam);
                    }
                }

                // Perform dependency injection checking on the obtained injection instance.
                if (!CanInject(baseParam.ParameterType, param))
                {
                    var error =
                        $"[{makeServiceBindData.Service}] Params inject type must be [{baseParam.ParameterType}] , But instance is [{param?.GetType()}]";
                    if (needService == null)
                    {
                        error += " Inject params from user incoming parameters.";
                    }
                    else
                    {
                        error += $" Make service is [{needService}].";
                    }

                    throw new UnresolvableException(error);
                }

                results[i] = param;
            }

            return results;
        }

        /// <summary>
        /// Determine if specified type is the default base type of the container.
        /// </summary>
        /// <param name="type">The specified type.</param>
        /// <returns>True if the specified type is the default base type. otherwise false.</returns>
        protected virtual bool IsBasicType(Type type)
        {
            return type == null || type.IsPrimitive || type == typeof(string);
        }

        /// <summary>
        /// Determine the specified type is cannot built.
        /// </summary>
        /// <param name="type">The specified type.</param>
        /// <returns>True if the specified type is cannot built. otherwise false.</returns>
        protected virtual bool IsUnableType(Type type)
        {
            return type == null || type.IsAbstract || type.IsInterface || type.IsArray || type.IsEnum
                || (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>));
        }

        /// <summary>
        /// Wrap a specified type.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <param name="concrete">The service concrete type.</param>
        /// <returns>Return a closure, call it to get the service instance.</returns>
        protected virtual Func<IContainer, object[], object> WrapperTypeBuilder(string service, Type concrete)
        {
            return (container, userParams) => ((Container)container).CreateInstance(GetBindFillable(service), concrete,
                userParams);
        }

        /// <summary>
        /// Get dependencies from the user parameters.
        /// </summary>
        /// <param name="baseParam">The depend type.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The instance that match the type of dependency.</returns>
        protected virtual object GetDependenciesFromUserParams(ParameterInfo baseParam, ref object[] userParams)
        {
            if (userParams == null)
            {
                return null;
            }

            GuardUserParamsCount(userParams.Length);

            for (var n = 0; n < userParams.Length; n++)
            {
                var userParam = userParams[n];

                if (!ChangeType(ref userParam, baseParam.ParameterType))
                {
                    continue;
                }

                Arr.RemoveAt(ref userParams, n);
                return userParam;
            }

            return null;
        }

        /// <summary>
        /// Convert instance to specified type.
        /// </summary>
        /// <param name="result">The instance.</param>
        /// <param name="conversionType">The specified type.</param>
        /// <returns>True if the conversion was successful, otherwise false.</returns>
        protected virtual bool ChangeType(ref object result, Type conversionType)
        {
            try
            {
                if (result == null || conversionType.IsInstanceOfType(result))
                {
                    return true;
                }

                if (IsBasicType(result.GetType()) && conversionType.IsDefined(typeof(VariantAttribute), false))
                {
                    try
                    {
                        result = Make(Type2Service(conversionType), result);
                        return true;
                    }
#pragma warning disable CA1031
                    catch (SException)
#pragma warning restore CA1031
                    {
                        // ignored
                        // when throw exception then stop inject
                    }
                }

                if (result is IConvertible && typeof(IConvertible).IsAssignableFrom(conversionType))
                {
                    result = Convert.ChangeType(result, conversionType);
                    return true;
                }
            }
#pragma warning disable CA1031
            catch (SException)
#pragma warning restore CA1031
            {
                // ignored
                // when throw exception then stop inject
            }

            return false;
        }

        /// <summary>
        /// Convert <see cref="PropertyInfo"/> to the service name.
        /// </summary>
        /// <param name="propertyInfo">The property.</param>
        /// <returns>The service name.</returns>
        protected virtual string GetPropertyNeedsService(PropertyInfo propertyInfo)
        {
            return Type2Service(propertyInfo.PropertyType);
        }

        /// <summary>
        /// Convert <see cref="ParameterInfo"/> to the service name.
        /// </summary>
        /// <param name="baseParam">The parameter.</param>
        /// <returns>The service name.</returns>
        protected virtual string GetParamNeedsService(ParameterInfo baseParam)
        {
            return Type2Service(baseParam.ParameterType);
        }

        /// <summary>
        /// Gets build closures based on context.
        /// </summary>
        /// <param name="makeServiceBindData">The bind data for the <see cref="Make"/> service.</param>
        /// <param name="service">The service name for dependent.</param>
        /// <param name="paramName">The parameter name for dependent.</param>
        /// <returns>The closure, call returned the dependency instance.</returns>
        protected virtual Func<object> GetContextualClosure(Bindable makeServiceBindData, string service,
            string paramName)
        {
            return makeServiceBindData.GetContextualClosure(service) ??
                   makeServiceBindData.GetContextualClosure($"{GetVariableTag()}{paramName}");
        }

        /// <inheritdoc cref="GetContextualClosure"/>
        /// <summary>
        /// Get build service based on context.
        /// </summary>
        /// <returns>The dependency service name.</returns>
        protected virtual string GetContextualService(Bindable makeServiceBindData, string service, string paramName)
        {
            return makeServiceBindData.GetContextual(service) ??
                   makeServiceBindData.GetContextual($"{GetVariableTag()}{paramName}") ??
                   service;
        }

        /// <summary>
        /// Gets the instance from closure.
        /// </summary>
        /// <param name="closure">The closure.</param>
        /// <param name="needType">The expected type.</param>
        /// <param name="ouput">The instance.</param>
        /// <returns>True if the build is successful and matches the expected type, otherwise false.</returns>
        protected virtual bool MakeFromContextualClosure(Func<object> closure, Type needType, out object ouput)
        {
            ouput = null;
            if (closure == null)
            {
                return false;
            }

            ouput = closure();
            return ChangeType(ref ouput, needType);
        }

        /// <inheritdoc cref="MakeFromContextualClosure"/>
        /// <summary>
        /// Gets the instance from service name.
        /// </summary>
        /// <param name="service">The service name.</param>
        protected virtual bool MakeFromContextualService(string service, Type needType, out object output)
        {
            output = null;
            if (!CanMake(service))
            {
                return false;
            }

            output = Make(service);
            return ChangeType(ref output, needType);
        }

        /// <summary>
        /// Resolve the specified service based on context.
        /// </summary>
        /// <param name="makeServiceBindData">The bind data for the <see cref="Make"/> service.</param>
        /// <param name="service">The service name for dependent.</param>
        /// <param name="paramName">The parameter or property name for dependent.</param>
        /// <param name="paramType">The parameter or property type for dependent.</param>
        /// <param name="output">The dependency instance.</param>
        /// <returns>True if build the dependency instance successful. otherwise false.</returns>
        protected virtual bool ResloveFromContextual(Bindable makeServiceBindData, string service, string paramName,
            Type paramType, out object output)
        {
            if (MakeFromContextualClosure(
                GetContextualClosure(makeServiceBindData, service, paramName),
                paramType, out output))
            {
                return true;
            }

            return MakeFromContextualService(
                GetContextualService(makeServiceBindData, service, paramName),
                paramType, out output);
        }

        /// <summary>
        /// Resolved the attribute selector's primitive type.
        /// </summary>
        /// <param name="makeServiceBindData">The bind data for the <see cref="Make"/> service.</param>
        /// <param name="service">The name or alias of the service dependent needs to resolved.</param>
        /// <param name="baseParam">The property for dependent.</param>
        /// <returns>The dependency instance.</returns>
        protected virtual object ResolveAttrPrimitive(Bindable makeServiceBindData, string service, PropertyInfo baseParam)
        {
            if (ResloveFromContextual(makeServiceBindData, service, baseParam.Name, baseParam.PropertyType,
                out object instance))
            {
                return instance;
            }

            if (baseParam.PropertyType.IsGenericType && baseParam.PropertyType.GetGenericTypeDefinition() ==
                typeof(Nullable<>))
            {
                return null;
            }

            var inject = (InjectAttribute)baseParam.GetCustomAttribute(typeof(InjectAttribute));
            if (inject != null && !inject.Required)
            {
                return skipped;
            }

            throw MakeUnresolvableException(baseParam.Name, baseParam.DeclaringType);
        }

        /// <inheritdoc cref="ResolveAttrPrimitive"/>
        /// <summary>
        /// Resolved the attribute selector's reference type.
        /// </summary>
        protected virtual object ResloveAttrClass(Bindable makeServiceBindData, string service, PropertyInfo baseParam)
        {
            if (ResloveFromContextual(makeServiceBindData, service, baseParam.Name, baseParam.PropertyType,
                out object instance))
            {
                return instance;
            }

            var inject = (InjectAttribute)baseParam.GetCustomAttribute(typeof(InjectAttribute));
            if (inject != null && !inject.Required)
            {
                return skipped;
            }

            throw MakeUnresolvableException(baseParam.Name, baseParam.DeclaringType);
        }

        /// <summary>
        /// Resolved the constructor's primitive type.
        /// </summary>
        /// <param name="makeServiceBindData">The bind data for the <see cref="Make"/> service.</param>
        /// <param name="service">The name or alias of the service dependent needs to resolved.</param>
        /// <param name="baseParam">The parameter for dependent.</param>
        /// <returns>The dependency instance.</returns>
        protected virtual object ResolvePrimitive(Bindable makeServiceBindData, string service, ParameterInfo baseParam)
        {
            if (ResloveFromContextual(makeServiceBindData, service, baseParam.Name, baseParam.ParameterType,
                out object instance))
            {
                return instance;
            }

            if (baseParam.IsOptional)
            {
                return baseParam.DefaultValue;
            }

            if (baseParam.ParameterType.IsGenericType && baseParam.ParameterType.GetGenericTypeDefinition() ==
                typeof(Nullable<>))
            {
                return null;
            }

            throw MakeUnresolvableException(
                baseParam.Name,
                baseParam.Member?.DeclaringType);
        }

        /// <inheritdoc cref="ResolvePrimitive"/>
        /// <summary>
        /// Resolved the constructor's reference type.
        /// </summary>
        protected virtual object ResloveClass(Bindable makeServiceBindData, string service, ParameterInfo baseParam)
        {
            if (ResloveFromContextual(makeServiceBindData, service, baseParam.Name, baseParam.ParameterType,
                out object instance))
            {
                return instance;
            }

            if (baseParam.IsOptional)
            {
                return baseParam.DefaultValue;
            }

            // baseParam.Member maybe empty and may occur when some underlying
            // development overwrites ParameterInfo class.
            throw MakeUnresolvableException(
                baseParam.Name,
                baseParam.Member?.DeclaringType);
        }

        /// <summary>
        /// Gets variable characters.
        /// </summary>
        /// <returns>The variable characters.</returns>
        protected virtual char GetVariableTag()
        {
            return '$';
        }

        /// <summary>
        /// Gets the debug message of the build stack.
        /// </summary>
        /// <returns>The debug message of the build stack.</returns>
        protected virtual string GetBuildStackDebugMessage()
        {
            var previous = string.Join(", ", BuildStack.ToArray());
            return $" While building stack [{previous}].";
        }

        /// <summary>
        /// Build a reslove failure exception.
        /// </summary>
        /// <param name="makeService">The <see cref="Make"/> service name.</param>
        /// <param name="makeServiceType">The <see cref="Make"/> service type.</param>
        /// <param name="innerException">The inner exception.</param>
        /// <returns>The resolve failure exception instance.</returns>
        protected virtual UnresolvableException MakeBuildFaildException(string makeService, Type makeServiceType, SException innerException)
        {
            var message = makeServiceType != null
                ? $"Class [{makeServiceType}] build faild. Service is [{makeService}]."
                : $"Service [{makeService}] is not exists.";

            message += GetBuildStackDebugMessage();
            message += GetInnerExceptionMessage(innerException);
            return new UnresolvableException(message, innerException);
        }

        /// <summary>
        /// Gets the inner exception debug message.
        /// </summary>
        /// <param name="innerException">The inner exception.</param>
        /// <returns>The debug message.</returns>
        protected virtual string GetInnerExceptionMessage(SException innerException)
        {
            if (innerException == null)
            {
                return string.Empty;
            }

            var stack = new StringBuilder();
            do
            {
                if (stack.Length > 0)
                {
                    stack.Append(", ");
                }

                stack.Append(innerException);
            }
            while ((innerException = innerException.InnerException) != null);
            return $" InnerException message stack: [{stack}]";
        }

        /// <summary>
        /// Build a unresolved exception.
        /// </summary>
        /// <param name="name">The parameter or property name for dependent.</param>
        /// <param name="declaringClass">Declaring class type for parameter or property.</param>
        /// <returns>The unresolved exception instance.</returns>
        protected virtual UnresolvableException MakeUnresolvableException(string name, Type declaringClass)
        {
            return new UnresolvableException(
                $"Unresolvable dependency , resolving [{name ?? "Unknow"}] in class [{declaringClass?.ToString() ?? "Unknow"}]");
        }

        /// <summary>
        /// Build a circular dependency exception.
        /// </summary>
        /// <param name="service">The name of the service that throws the exception.</param>
        /// <returns>The circular dependency exception.</returns>
        protected virtual LogicException MakeCircularDependencyException(string service)
        {
            var message = $"Circular dependency detected while for [{service}].";
            message += GetBuildStackDebugMessage();
            return new LogicException(message);
        }

        /// <summary>
        /// Format the service name.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <returns>The formatted service name.</returns>
        protected virtual string FormatService(string service)
        {
            return service.Trim();
        }

        /// <summary>
        /// Check if the specified instance can be injected.
        /// </summary>
        /// <param name="type">The expected type.</param>
        /// <param name="instance">The specified instance.</param>
        /// <returns>True if the instance can be injected. otherwise false.</returns>
        protected virtual bool CanInject(Type type, object instance)
        {
            return instance == null || type.IsInstanceOfType(instance);
        }

        /// <summary>
        /// Ensure that the number of parameters passed in by the user must be less than the specified value.
        /// </summary>
        /// <param name="count">The specified count.</param>
        protected virtual void GuardUserParamsCount(int count)
        {
            if (count > 255)
            {
                throw new LogicException($"Too many parameters , must be less or equal than 255 or override the {nameof(GuardUserParamsCount)} method.");
            }
        }

        /// <summary>
        /// Ensure that the specified instance is valid.
        /// </summary>
        /// <param name="instance">The specified instance.</param>
        /// <param name="makeService">The <see cref="Make"/> service name.</param>
        protected virtual void GuardResolveInstance(object instance, string makeService)
        {
            if (instance == null)
            {
                throw MakeBuildFaildException(makeService, SpeculatedServiceType(makeService), null);
            }
        }

        /// <summary>
        /// Speculative service type based on specified service name.
        /// </summary>
        /// <param name="service">The specified service name.</param>
        /// <returns>The speculative service type.</returns>
        protected virtual Type SpeculatedServiceType(string service)
        {
            if (findTypeCache.TryGetValue(service, out Type result))
            {
                return result;
            }

            foreach (var finder in findType)
            {
                var type = finder.Invoke(service);
                if (type != null)
                {
                    return findTypeCache[service] = type;
                }
            }

            return findTypeCache[service] = null;
        }

        /// <summary>
        /// Dependency injection on the property selector.
        /// </summary>
        /// <param name="makeServiceBindData">The bind data for <see cref="Make"/> service.</param>
        /// <param name="makeServiceInstance">The instance for <see cref="Make"/> service.</param>
        protected virtual void AttributeInject(Bindable makeServiceBindData, object makeServiceInstance)
        {
            if (makeServiceInstance == null)
            {
                return;
            }

            foreach (var property in makeServiceInstance.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                if (!property.CanWrite
                    || !property.IsDefined(typeof(InjectAttribute), false))
                {
                    continue;
                }

                var needService = GetPropertyNeedsService(property);

                object instance;
                if (property.PropertyType.IsClass
                    || property.PropertyType.IsInterface)
                {
                    instance = ResloveAttrClass(makeServiceBindData, needService, property);
                }
                else
                {
                    instance = ResolveAttrPrimitive(makeServiceBindData, needService, property);
                }

                if (ReferenceEquals(instance, skipped))
                {
                    continue;
                }

                if (!CanInject(property.PropertyType, instance))
                {
                    throw new UnresolvableException(
                        $"[{makeServiceBindData.Service}]({makeServiceInstance.GetType()}) Attr inject type must be [{property.PropertyType}] , But instance is [{instance?.GetType()}] , Make service is [{needService}].");
                }

                property.SetValue(makeServiceInstance, instance, null);
            }
        }

        /// <summary>
        /// Check if the parameter passed in by the user can be injected compact.
        /// </summary>
        /// <param name="baseParam">The parameter for dependent.</param>
        /// <param name="userParams">An array for the user parameter.</param>
        /// <returns>True if the parameter can be injected tightly. otherwise false.</returns>
        protected virtual bool CheckCompactInjectUserParams(ParameterInfo baseParam, object[] userParams)
        {
            if (userParams == null || userParams.Length <= 0)
            {
                return false;
            }

            return baseParam.ParameterType == typeof(object[])
                   || baseParam.ParameterType == typeof(object);
        }

        /// <summary>
        /// Gets the parameters injected through the compact.
        /// </summary>
        /// <param name="baseParam">The parameter for dependent.</param>
        /// <param name="userParams">An array for the user parameter.</param>
        /// <returns>Parameters that can be injected in a compact.</returns>
        protected virtual object GetCompactInjectUserParams(ParameterInfo baseParam, ref object[] userParams)
        {
            if (!CheckCompactInjectUserParams(baseParam, userParams))
            {
                return null;
            }

            try
            {
                if (baseParam.ParameterType == typeof(object)
                    && userParams != null && userParams.Length == 1)
                {
                    return userParams[0];
                }

                return userParams;
            }
            finally
            {
                userParams = null;
            }
        }

        /// <summary>
        /// Gets the parameter matcher.
        /// </summary>
        /// <param name="userParams">An array for the user parameter.</param>
        /// <returns>Returns the parameter matcher, if it is null, there is no matcher.</returns>
        protected virtual Func<ParameterInfo, object> GetParamsMatcher(ref object[] userParams)
        {
            if (userParams == null || userParams.Length <= 0)
            {
                return null;
            }

            var tables = GetParamsTypeInUserParams(ref userParams);
            return tables.Length <= 0 ? null : MakeParamsMatcher(tables);
        }

        /// <summary>
        /// Select the appropriate constructor and get the corresponding array of parameter instances.
        /// </summary>
        /// <param name="makeServiceBindData">The bind data for <see cref="Make"/> service.</param>
        /// <param name="makeServiceType">The type for <see cref="Make"/> service.</param>
        /// <param name="userParams">An array for the user parameter.</param>
        /// <returns>An array of resolved instances for dependent parameters.</returns>
        protected virtual object[] GetConstructorsInjectParams(Bindable makeServiceBindData, Type makeServiceType, object[] userParams)
        {
            var constructors = makeServiceType.GetConstructors();
            if (constructors.Length <= 0)
            {
                return Array.Empty<object>();
            }

            ExceptionDispatchInfo exceptionDispatchInfo = null;
            foreach (var constructor in constructors)
            {
                try
                {
                    return GetDependencies(makeServiceBindData, constructor.GetParameters(), userParams);
                }
#pragma warning disable CA1031
                catch (SException ex)
                {
                    if (exceptionDispatchInfo == null)
                    {
                        exceptionDispatchInfo = ExceptionDispatchInfo.Capture(ex);
                    }
                }
#pragma warning restore CA1031
            }

            exceptionDispatchInfo?.Throw();
            throw new AssertException("Exception dispatch info is null.");
        }

        /// <summary>
        /// Get the service name of the specified instance.
        /// </summary>
        /// <param name="instance">The specified instance.</param>
        /// <returns>Returns the service name, or null if not found.</returns>
        protected string GetServiceWithInstanceObject(object instance)
        {
            return instancesReverse.TryGetValue(instance, out string origin)
                ? origin
                : null;
        }

        /// <summary>
        /// Verify that the current construct is valid.
        /// </summary>
        /// <param name="method">Called function name.</param>
        protected virtual void GuardConstruct(string method)
        {
        }

        /// <summary>
        /// Verify service name validity.
        /// </summary>
        /// <param name="service">The service name.</param>
        protected virtual void GuardServiceName(string service)
        {
            foreach (var c in ServiceBanChars)
            {
                if (service.IndexOf(c) >= 0)
                {
                    throw new LogicException(
                        $"Service name {service} contains disabled characters : {c}. please use Alias replacement");
                }
            }
        }

        /// <summary>
        /// Verify function name validity.
        /// </summary>
        /// <param name="method">The method name.</param>
        protected virtual void GuardMethodName(string method)
        {
        }

        /// <summary>
        /// Build an empty bound data.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <returns>The bound data.</returns>
        protected virtual BindData MakeEmptyBindData(string service)
        {
            return new BindData(this, service, null, false);
        }

        /// <summary>
        /// Resolve the specified service(Will not perform <see cref="GuardConstruct"/> check).
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <param name="userParams">An array for the user parameter.</param>
        /// <returns>The service instance.</returns>
        protected object Resolve(string service, params object[] userParams)
        {
            Guard.ParameterNotNull(service, nameof(service));

            service = AliasToService(service);
            if (instances.TryGetValue(service, out object instance))
            {
                return instance;
            }

            if (BuildStack.Contains(service))
            {
                throw MakeCircularDependencyException(service);
            }

            BuildStack.Push(service);
            UserParamsStack.Push(userParams);
            try
            {
                var bindData = GetBindFillable(service);

                // We will start building a service instance，
                // For the built service we will try to do dependency injection。
                instance = Build(bindData, userParams);

                // If we define an extender for the specified service, then we need
                // to execute the expander in turn，And allow the extender to modify
                // or overwrite the original service。
                instance = Extend(service, instance);

                instance = bindData.IsStatic
                    ? Instance(bindData.Service, instance)
                    : TriggerOnResolving(bindData, instance);

                resolved.Add(bindData.Service);
                return instance;
            }
            finally
            {
                UserParamsStack.Pop();
                BuildStack.Pop();
            }
        }

        /// <summary>
        /// Build the specified service.
        /// </summary>
        /// <param name="makeServiceBindData">The bind data for the <see cref="Make"/> service.</param>
        /// <param name="userParams">An array for the user parameter.</param>
        /// <returns>The service instance.</returns>
        protected virtual object Build(BindData makeServiceBindData, object[] userParams)
        {
            var instance = makeServiceBindData.Concrete != null
                ? makeServiceBindData.Concrete(this, userParams)
                : CreateInstance(makeServiceBindData, SpeculatedServiceType(makeServiceBindData.Service),
                    userParams);

            return Inject(makeServiceBindData, instance);
        }

        /// <summary>
        /// Create the specified service instance.
        /// </summary>
        /// <param name="makeServiceBindData">The bind data for the <see cref="Make"/> service.</param>
        /// <param name="makeServiceType">The type for the <see cref="Make"/> service.</param>
        /// <param name="userParams">An array for the user parameter.</param>
        /// <returns>The service instance.</returns>
        protected virtual object CreateInstance(Bindable makeServiceBindData, Type makeServiceType, object[] userParams)
        {
            if (IsUnableType(makeServiceType))
            {
                return null;
            }

            userParams = GetConstructorsInjectParams(makeServiceBindData, makeServiceType, userParams);

            try
            {
                return CreateInstance(makeServiceType, userParams);
            }
#pragma warning disable CA1031
            catch (SException ex)
#pragma warning restore CA1031
            {
                throw MakeBuildFaildException(makeServiceBindData.Service, makeServiceType, ex);
            }
        }

        /// <inheritdoc cref="CreateInstance(Bindable, Type, object[])"/>
        protected virtual object CreateInstance(Type makeServiceType, object[] userParams)
        {
            // If the parameter does not exist then you can get better
            // performance without writing parameters when reflecting.
            if (userParams == null || userParams.Length <= 0)
            {
                return Activator.CreateInstance(makeServiceType);
            }

            return Activator.CreateInstance(makeServiceType, userParams);
        }

        /// <summary>
        /// Get the service binding data, fill the data if the data is null.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <returns>The bind data for the service.</returns>
        protected BindData GetBindFillable(string service)
        {
            return service != null && bindings.TryGetValue(service, out BindData bindData)
                ? bindData
                : MakeEmptyBindData(service);
        }

        /// <summary>
        /// Guaranteed not to be flushing.
        /// </summary>
        private void GuardFlushing()
        {
            if (flushing)
            {
                throw new LogicException("Container is flushing can not do it");
            }
        }

        /// <summary>
        /// Convert an alias to a service name.
        /// </summary>
        /// <param name="name">The service name or alias.</param>
        /// <returns>The service name.</returns>
        private string AliasToService(string name)
        {
            name = FormatService(name);
            return aliases.TryGetValue(name, out string alias) ? alias : name;
        }

        /// <summary>
        /// Trigger all of the resolving callbacks.
        /// </summary>
        /// <param name="bindData">The bind data for <see cref="Make"/> service.</param>
        /// <param name="instance">The service instance.</param>
        /// <returns>The decorated service instance.</returns>
        private object TriggerOnResolving(BindData bindData, object instance)
        {
            instance = bindData.TriggerResolving(instance);
            instance = Trigger(bindData, instance, resolving);
            return TriggerOnAfterResolving(bindData, instance);
        }

        /// <inheritdoc cref="TriggerOnResolving"/>
        /// <summary>
        /// Trigger all of the after resolving callbacks.
        /// </summary>
        private object TriggerOnAfterResolving(BindData bindData, object instance)
        {
            instance = bindData.TriggerAfterResolving(instance);
            return Trigger(bindData, instance, afterResloving);
        }

        /// <inheritdoc cref="TriggerOnResolving"/>
        /// <summary>
        /// Trigger all of the release callbacks.
        /// </summary>
        private void TriggerOnRelease(IBindData bindData, object instance)
        {
            Trigger(bindData, instance, release);
        }

        /// <summary>
        /// Trigger the rebound callbacks for specified service instance.
        /// </summary>
        /// <param name="service">The specified service name.</param>
        /// <param name="instance">
        /// The specified service instance.
        /// Build from the container by service name if a null value is passed in.
        /// </param>
        private void TriggerOnRebound(string service, object instance = null)
        {
            var callbacks = GetOnReboundCallbacks(service);
            if (callbacks == null || callbacks.Count <= 0)
            {
                return;
            }

            var bind = GetBind(service);
            instance = instance ?? Make(service);

            for (var index = 0; index < callbacks.Count; index++)
            {
                callbacks[index](instance);

                // If it is a not singleton(static) binding then each callback is given a separate instance.
                if (index + 1 < callbacks.Count && (bind == null || !bind.IsStatic))
                {
                    instance = Make(service);
                }
            }
        }

        /// <summary>
        /// Release the specified instance via <see cref="IDisposable"/>.
        /// </summary>
        /// <param name="instance">The specified instance.</param>
        private void DisposeInstance(object instance)
        {
            if (instance is IDisposable disposable)
            {
                disposable.Dispose();
            }
        }

        /// <summary>
        /// Gets the specified service all of the rebound callbacks.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <returns>The rebound callbacks list.</returns>
        private IList<Action<object>> GetOnReboundCallbacks(string service)
        {
            return !rebound.TryGetValue(service, out List<Action<object>> result) ? null : result;
        }

        /// <summary>
        /// Check if there is a callback for the rebound service.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <returns>True if the rebound callback exists. otherwise false.</returns>
        private bool HasOnReboundCallbacks(string service)
        {
            var result = GetOnReboundCallbacks(service);
            return result != null && result.Count > 0;
        }

        /// <summary>
        /// Trigger all of the extend callbacks.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <param name="instance">The service instance.</param>
        /// <returns>The decorated instance.</returns>
        private object Extend(string service, object instance)
        {
            if (extenders.TryGetValue(service, out List<Func<object, IContainer, object>> list))
            {
                foreach (var extender in list)
                {
                    instance = extender(instance, this);
                }
            }

            if (!extenders.TryGetValue(string.Empty, out list))
            {
                return instance;
            }

            foreach (var extender in list)
            {
                instance = extender(instance, this);
            }

            return instance;
        }

        /// <summary>
        /// Dependency injection for specified instance.
        /// </summary>
        /// <param name="bindable">The bindable for the instance.</param>
        /// <param name="instance">The instance.</param>
        /// <returns>An instance of injection has been completed.</returns>
        private object Inject(Bindable bindable, object instance)
        {
            GuardResolveInstance(instance, bindable.Service);

            AttributeInject(bindable, instance);

            return instance;
        }

        /// <summary>
        /// Get the variable of type <see cref="IParams"/> from <paramref name="userParams"/>.
        /// </summary>
        /// <param name="userParams">An array for the user parameter.</param>
        /// <returns>An array of <see cref="IParams"/> parameters.</returns>
        private IParams[] GetParamsTypeInUserParams(ref object[] userParams)
        {
            // Filter is used here without using Remove because
            // the IParams is also one of the types that you might want to inject.
            var elements = Arr.Filter(userParams, value => value is IParams);
            var results = new IParams[elements.Length];
            for (var i = 0; i < elements.Length; i++)
            {
                results[i] = (IParams)elements[i];
            }

            return results;
        }

        /// <summary>
        /// Generate a default parameter <see cref="IParams" /> matcher.
        /// </summary>
        /// <param name="tables">An array of <see cref="IParams"/> parameters.</param>
        /// <returns>The default parameter matcher.</returns>
        private Func<ParameterInfo, object> MakeParamsMatcher(IParams[] tables)
        {
            // The default matcher policy will match the parameter name
            // with the parameter name of the parameter table.

            // The first valid valid parameter value will be returned
            // as the return value
            return parameterInfo =>
            {
                foreach (var table in tables)
                {
                    if (!table.TryGetValue(parameterInfo.Name, out object result))
                    {
                        continue;
                    }

                    if (ChangeType(ref result, parameterInfo.ParameterType))
                    {
                        return result;
                    }
                }

                return null;
            };
        }

        /// <summary>
        /// Register a new callback in specified list.
        /// </summary>
        /// <param name="closure">The callback.</param>
        /// <param name="list">The specified list.</param>
        private void AddClosure(Action<IBindData, object> closure, List<Action<IBindData, object>> list)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            GuardFlushing();
            list.Add(closure);
        }
    }
}


================================================
FILE: src/CatLib.Core/Container/ContainerExtension.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

#pragma warning disable SA1618

using CatLib.Exception;
using CatLib.Util;
using System;

namespace CatLib.Container
{
    /// <summary>
    /// An extension function for <see cref="Container"/>.
    /// </summary>
    public static class ContainerExtension
    {
        /// <summary>
        /// Gets the binding data of the given service.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>Return null If there is no binding data.</returns>
        public static IBindData GetBind<TService>(this IContainer container)
        {
            return container.GetBind(container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Whether the given service has been bound.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>True if the service has been bound.</returns>
        public static bool HasBind<TService>(this IContainer container)
        {
            return container.HasBind(container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Whether the existing instance is exists in the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>True if the instance existed.</returns>
        public static bool HasInstance<TService>(this IContainer container)
        {
            return container.HasInstance(container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Whether the service has been resolved.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>True if the service has been resolved.</returns>
        public static bool IsResolved<TService>(this IContainer container)
        {
            return container.IsResolved(container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Whether the given service can be made.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>True if the given service can be made.</returns>
        public static bool CanMake<TService>(this IContainer container)
        {
            return container.CanMake(container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Whether the given service is singleton bind. false if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>True if the service is singleton bind.</returns>
        public static bool IsStatic<TService>(this IContainer container)
        {
            return container.IsStatic(container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Whether the given name is an alias.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>True if the given name is an alias.</returns>
        public static bool IsAlias<TService>(this IContainer container)
        {
            return container.IsAlias(container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Alias a service to a different name.
        /// </summary>
        /// <typeparam name="TAlias">The alias name.</typeparam>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The container instance.</param>
        /// <returns>Returns the container instance.</returns>
        public static IContainer Alias<TAlias, TService>(this IContainer container)
        {
            return container.Alias(container.Type2Service(typeof(TAlias)), container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Register a binding with the container.
        /// </summary>
        /// <typeparam name="TService">The service name (also indicates specific implementation).</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Bind<TService>(this IContainer container)
        {
            return container.Bind(container.Type2Service(typeof(TService)), typeof(TService), false);
        }

        /// <summary>
        /// Register a binding with the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <typeparam name="TConcrete">The service concrete.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Bind<TService, TConcrete>(this IContainer container)
        {
            return container.Bind(container.Type2Service(typeof(TService)), typeof(TConcrete), false);
        }

        /// <summary>
        /// Register a binding with the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Bind<TService>(this IContainer container, Func<IContainer, object[], object> concrete)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.Bind(container.Type2Service(typeof(TService)), concrete, false);
        }

        /// <summary>
        /// Register a binding with the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Bind<TService>(this IContainer container, Func<object[], object> concrete)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.Bind(container.Type2Service(typeof(TService)), (c, p) => concrete.Invoke(p), false);
        }

        /// <summary>
        /// Register a binding with the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Bind<TService>(this IContainer container, Func<object> concrete)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.Bind(container.Type2Service(typeof(TService)), (c, p) => concrete.Invoke(), false);
        }

        /// <summary>
        /// Register a binding with the container.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="service">The service name.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Bind(this IContainer container, string service,
            Func<IContainer, object[], object> concrete)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.Bind(service, concrete, false);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <typeparam name="TConcrete">The service concrete.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool BindIf<TService, TConcrete>(this IContainer container, out IBindData bindData)
        {
            return container.BindIf(container.Type2Service(typeof(TService)), typeof(TConcrete), false, out bindData);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name (also indicates specific implementation).</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool BindIf<TService>(this IContainer container, out IBindData bindData)
        {
            return container.BindIf(container.Type2Service(typeof(TService)), typeof(TService), false, out bindData);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool BindIf<TService>(this IContainer container, Func<IContainer, object[], object> concrete, out IBindData bindData)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.BindIf(container.Type2Service(typeof(TService)), concrete, false, out bindData);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool BindIf<TService>(this IContainer container, Func<object[], object> concrete, out IBindData bindData)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.BindIf(container.Type2Service(typeof(TService)), (c, @params) => concrete(@params), false,
                out bindData);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool BindIf<TService>(this IContainer container, Func<object> concrete, out IBindData bindData)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.BindIf(container.Type2Service(typeof(TService)), (c, p) => concrete.Invoke(), false,
                out bindData);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="service">The service name.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool BindIf(this IContainer container, string service,
            Func<IContainer, object[], object> concrete, out IBindData bindData)
        {
            return container.BindIf(service, concrete, false, out bindData);
        }

        /// <summary>
        /// Register a singleton binding with the container.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="service">The service name.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Singleton(this IContainer container, string service,
            Func<IContainer, object[], object> concrete)
        {
            return container.Bind(service, concrete, true);
        }

        /// <summary>
        /// Register a singleton binding with the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <typeparam name="TConcrete">The service concrete.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Singleton<TService, TConcrete>(this IContainer container)
        {
            return container.Bind(container.Type2Service(typeof(TService)), typeof(TConcrete), true);
        }

        /// <summary>
        /// Register a singleton binding with the container.
        /// </summary>
        /// <typeparam name="TService">The service name (also indicates specific implementation).</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Singleton<TService>(this IContainer container)
        {
            return container.Bind(container.Type2Service(typeof(TService)), typeof(TService), true);
        }

        /// <summary>
        /// Register a singleton binding with the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Singleton<TService>(
            this IContainer container,
            Func<IContainer, object[], object> concrete)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.Bind(container.Type2Service(typeof(TService)), concrete, true);
        }

        /// <summary>
        /// Register a singleton binding with the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Singleton<TService>(this IContainer container, Func<object[], object> concrete)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.Bind(container.Type2Service(typeof(TService)), (c, p) => concrete.Invoke(p), true);
        }

        /// <summary>
        /// Register a singleton binding with the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <returns>The service binding data.</returns>
        public static IBindData Singleton<TService>(
            this IContainer container,
            Func<object> concrete)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.Bind(container.Type2Service(typeof(TService)), (c, p) => concrete.Invoke(), true);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <typeparam name="TConcrete">The service concrete.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool SingletonIf<TService, TConcrete>(this IContainer container, out IBindData bindData)
        {
            return container.BindIf(container.Type2Service(typeof(TService)), typeof(TConcrete), true, out bindData);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name (also indicates specific implementation).</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool SingletonIf<TService>(this IContainer container, out IBindData bindData)
        {
            return container.BindIf(container.Type2Service(typeof(TService)), typeof(TService), true, out bindData);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool SingletonIf<TService>(this IContainer container, Func<IContainer, object[], object> concrete, out IBindData bindData)
        {
            return container.BindIf(container.Type2Service(typeof(TService)), concrete, true, out bindData);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool SingletonIf<TService>(this IContainer container, Func<object> concrete, out IBindData bindData)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.BindIf(container.Type2Service(typeof(TService)), (c, p) => concrete.Invoke(), true,
                out bindData);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool SingletonIf<TService>(this IContainer container, Func<object[], object> concrete, out IBindData bindData)
        {
            Guard.Requires<ArgumentNullException>(concrete != null);
            return container.BindIf(container.Type2Service(typeof(TService)), (c, @params) => concrete(@params), true,
                out bindData);
        }

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="service">The service name.</param>
        /// <param name="concrete">The service concrete.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        public static bool SingletonIf(this IContainer container, string service,
            Func<IContainer, object[], object> concrete, out IBindData bindData)
        {
            return container.BindIf(service, concrete, true, out bindData);
        }

        /// <summary>
        /// Register a method with the container.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method name.</param>
        /// <param name="target">The invoking target.</param>
        /// <param name="call">The method info to invoke.</param>
        /// <returns>Returns the method bind instance.</returns>
        public static IMethodBind BindMethod(this IContainer container, string method, object target, string call = null)
        {
            Guard.ParameterNotNull(method, nameof(method));
            Guard.ParameterNotNull(target, nameof(target));

            return container.BindMethod(method, target, target.GetType().GetMethod(call ?? Str.Method(method)));
        }

        /// <summary>
        /// Register a method with the container.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method name.</param>
        /// <param name="callback">The method to invoke.</param>
        /// <returns>Returns the method bind instance.</returns>
        public static IMethodBind BindMethod(this IContainer container, string method, Func<object> callback)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            Guard.Requires<ArgumentNullException>(callback != null);
            return container.BindMethod(method, callback.Target, callback.Method);
        }

        /// <summary>
        /// Register a method with the container.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method name.</param>
        /// <param name="callback">The method to invoke.</param>
        /// <returns>Returns the method bind instance.</returns>
        public static IMethodBind BindMethod<T1>(this IContainer container, string method, Func<T1, object> callback)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            Guard.Requires<ArgumentNullException>(callback != null);
            return container.BindMethod(method, callback.Target, callback.Method);
        }

        /// <summary>
        /// Register a method with the container.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method name.</param>
        /// <param name="callback">The method to invoke.</param>
        /// <returns>Returns the method bind instance.</returns>
        public static IMethodBind BindMethod<T1, T2>(this IContainer container, string method, Func<T1, T2, object> callback)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            Guard.Requires<ArgumentNullException>(callback != null);
            return container.BindMethod(method, callback.Target, callback.Method);
        }

        /// <summary>
        /// Register a method with the container.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method name.</param>
        /// <param name="callback">The method to invoke.</param>
        /// <returns>Returns the method bind instance.</returns>
        public static IMethodBind BindMethod<T1, T2, T3>(this IContainer container, string method, Func<T1, T2, T3, object> callback)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            Guard.Requires<ArgumentNullException>(callback != null);
            return container.BindMethod(method, callback.Target, callback.Method);
        }

        /// <summary>
        /// Register a method with the container.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method name.</param>
        /// <param name="callback">The method to invoke.</param>
        /// <returns>Returns the method bind instance.</returns>
        public static IMethodBind BindMethod<T1, T2, T3, T4>(this IContainer container, string method, Func<T1, T2, T3, T4, object> callback)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            Guard.Requires<ArgumentNullException>(callback != null);
            return container.BindMethod(method, callback.Target, callback.Method);
        }

        /// <summary>
        /// Unbinds a service from the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        public static void Unbind<TService>(this IContainer container)
        {
            container.Unbind(container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Assign a set of tags to a given binding.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="tag">The tag name.</param>
        public static void Tag<TService>(this IContainer container, string tag)
        {
            container.Tag(tag, container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Register an existing instance as shared in the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="instance">The service instance.</param>
        /// <returns>Object processed by the decorator.</returns>
        public static object Instance<TService>(this IContainer container, object instance)
        {
            return container.Instance(container.Type2Service(typeof(TService)), instance);
        }

        /// <summary>
        /// Release an existing instance in the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>True if the instance is released. otherwise if instance not exits return false.</returns>
        public static bool Release<TService>(this IContainer container)
        {
            return container.Release(container.Type2Service(typeof(TService)));
        }

        /// <summary>
        /// Release an existing instance in the container.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="instances">Service instance that needs to be released.</param>
        /// <param name="reverse">Whether to reverse the release order.</param>
        /// <returns>Returns false if one has not been successfully released, <paramref name="instances"/> is an instance that has not been released.</returns>
        public static bool Release(this IContainer container, ref object[] instances, bool reverse = true)
        {
            if (instances == null || instances.Length <= 0)
            {
                return true;
            }

            if (reverse)
            {
                Array.Reverse(instances);
            }

            var errorIndex = 0;

            for (var index = 0; index < instances.Length; index++)
            {
                if (instances[index] == null)
                {
                    continue;
                }

                if (!container.Release(instances[index]))
                {
                    instances[errorIndex++] = instances[index];
                }
            }

            Array.Resize(ref instances, errorIndex);

            if (reverse && errorIndex > 0)
            {
                Array.Reverse(instances);
            }

            return errorIndex <= 0;
        }

        /// <summary>
        /// Call the given method and inject its dependencies.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method to called.</param>
        /// <param name="userParams">The user parameters.</param>
        public static void Call<T1>(this IContainer container, Action<T1> method, params object[] userParams)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            container.Call(method.Target, method.Method, userParams);
        }

        /// <summary>
        /// Call the given method and inject its dependencies.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method to called.</param>
        /// <param name="userParams">The user parameters.</param>
        public static void Call<T1, T2>(this IContainer container, Action<T1, T2> method, params object[] userParams)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            container.Call(method.Target, method.Method, userParams);
        }

        /// <summary>
        /// Call the given method and inject its dependencies.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method to called.</param>
        /// <param name="userParams">The user parameters.</param>
        public static void Call<T1, T2, T3>(this IContainer container, Action<T1, T2, T3> method, params object[] userParams)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            container.Call(method.Target, method.Method, userParams);
        }

        /// <summary>
        /// Call the given method and inject its dependencies.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method to called.</param>
        /// <param name="userParams">The user parameters.</param>
        public static void Call<T1, T2, T3, T4>(this IContainer container, Action<T1, T2, T3, T4> method, params object[] userParams)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            container.Call(method.Target, method.Method, userParams);
        }

        /// <summary>
        /// Call the given method and inject its dependencies.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="target">The instance on which to call the method.</param>
        /// <param name="method">The method name.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The return value of method.</returns>
        public static object Call(this IContainer container, object target, string method, params object[] userParams)
        {
            Guard.ParameterNotNull(method, nameof(method));
            Guard.ParameterNotNull(target, nameof(target));

            var methodInfo = target.GetType().GetMethod(method);

            if (methodInfo == null)
            {
                throw new LogicException($"Function \"{method}\" not found.");
            }

            return container.Call(target, methodInfo, userParams);
        }

        /// <summary>
        /// Wrap a method called in a dependency injection form.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method to called.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>Return the wrapper method, which can be called to trigger another method in the form of dependency injection.</returns>
        public static Action Wrap<T1>(this IContainer container, Action<T1> method, params object[] userParams)
        {
            return () =>
            {
                if (method != null)
                {
                    container.Call(method.Target, method.Method, userParams);
                }
            };
        }

        /// <summary>
        /// Wrap a method called in a dependency injection form.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method to called.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>Return the wrapper method, which can be called to trigger another method in the form of dependency injection.</returns>
        public static Action Wrap<T1, T2>(this IContainer container, Action<T1, T2> method, params object[] userParams)
        {
            return () =>
            {
                if (method != null)
                {
                    container.Call(method.Target, method.Method, userParams);
                }
            };
        }

        /// <summary>
        /// Wrap a method called in a dependency injection form.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method to called.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>Return the wrapper method, which can be called to trigger another method in the form of dependency injection.</returns>
        public static Action Wrap<T1, T2, T3>(this IContainer container, Action<T1, T2, T3> method, params object[] userParams)
        {
            return () =>
            {
                if (method != null)
                {
                    container.Call(method.Target, method.Method, userParams);
                }
            };
        }

        /// <summary>
        /// Wrap a method called in a dependency injection form.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The method to called.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>Return the wrapper method, which can be called to trigger another method in the form of dependency injection.</returns>
        public static Action Wrap<T1, T2, T3, T4>(this IContainer container, Action<T1, T2, T3, T4> method, params object[] userParams)
        {
            return () =>
            {
                if (method != null)
                {
                    container.Call(method.Target, method.Method, userParams);
                }
            };
        }

        /// <summary>
        /// Resolve the given service or alias from the container.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The serivce instance. Throw exception if the service can not resolved.</returns>
        public static TService Make<TService>(this IContainer container, params object[] userParams)
        {
            return (TService)container.Make(container.Type2Service(typeof(TService)), userParams);
        }

        /// <summary>
        /// Resolve the given service or alias from the container.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="type">The service type.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The serivce instance. Throw exception if the service can not resolved.</returns>
        public static object Make(this IContainer container, Type type, params object[] userParams)
        {
            var service = container.Type2Service(type);
            container.BindIf(service, type, false, out _);
            return container.Make(service, userParams);
        }

        /// <summary>
        /// <see cref="Extend"/> an abstract type in the container.
        /// <para>Allow configuration or replacement of services during service resolving.</para>
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="service">The service name.</param>
        /// <param name="closure">The closure.</param>
        public static void Extend(this IContainer container, string service, Func<object, object> closure)
        {
            container.Extend(service, (instance, c) => closure(instance));
        }

        /// <summary>
        /// <see cref="Extend"/> an abstract type in the container.
        /// <para>Allow configuration or replacement of services during service resolving.</para>
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="closure">The closure.</param>
        public static void Extend<TService, TConcrete>(this IContainer container, Func<TConcrete, object> closure)
        {
            container.Extend(container.Type2Service(typeof(TService)), (instance, c) => closure((TConcrete)instance));
        }

        /// <summary>
        /// <see cref="Extend"/> an abstract type in the container.
        /// <para>Allow configuration or replacement of services during service resolving.</para>
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="closure">The closure.</param>
        public static void Extend<TService, TConcrete>(this IContainer container, Func<TConcrete, IContainer, object> closure)
        {
            container.Extend(
                container.Type2Service(typeof(TService)),
                (instance, c) => closure((TConcrete)instance, c));
        }

        /// <summary>
        /// <see cref="Extend"/> an abstract type in the container.
        /// <para>Allow configuration or replacement of services during service resolving.</para>
        /// </summary>
        /// <typeparam name="TConcrete">Expected type or interface.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="closure">The closure.</param>
        public static void Extend<TConcrete>(this IContainer container, Func<TConcrete, IContainer, object> closure)
        {
            container.Extend(null, (instance, c) =>
            {
                if (instance is TConcrete)
                {
                    return closure((TConcrete)instance, c);
                }

                return instance;
            });
        }

        /// <summary>
        /// <see cref="Extend"/> an abstract type in the container.
        /// <para>Allow configuration or replacement of services during service resolving.</para>
        /// </summary>
        /// <typeparam name="TConcrete">Expected type or interface.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="closure">The closure.</param>
        public static void Extend<TConcrete>(this IContainer container, Func<TConcrete, object> closure)
        {
            container.Extend(null, (instance, _) =>
            {
                if (instance is TConcrete)
                {
                    return closure((TConcrete)instance);
                }

                return instance;
            });
        }

        /// <summary>
        /// Register a new release callback.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="callback">The callback.</param>
        /// <returns>Returns the <see cref="IContainer"/> instance.</returns>
        public static IContainer OnRelease(this IContainer container, Action<object> callback)
        {
            Guard.Requires<ArgumentNullException>(callback != null);
            return container.OnRelease((_, instance) => callback(instance));
        }

        /// <summary>
        /// Register a new release callback.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="closure">The callback.</param>
        /// <returns>Returns the <see cref="IContainer"/> instance.</returns>
        public static IContainer OnRelease<T>(this IContainer container, Action<T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return container.OnRelease((_, instance) =>
            {
                if (instance is T)
                {
                    closure((T)instance);
                }
            });
        }

        /// <summary>
        /// Register a new release callback.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="closure">The callback.</param>
        /// <returns>Returns the <see cref="IContainer"/> instance.</returns>
        public static IContainer OnRelease<T>(this IContainer container, Action<IBindData, T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return container.OnRelease((bindData, instance) =>
            {
                if (instance is T)
                {
                    closure(bindData, (T)instance);
                }
            });
        }

        /// <summary>
        /// Register a new resolving callback.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="callback">The callback.</param>
        /// <returns>Returns the <see cref="IContainer"/> instance.</returns>
        public static IContainer OnResolving(this IContainer container, Action<object> callback)
        {
            Guard.Requires<ArgumentNullException>(callback != null);
            return container.OnResolving((_, instance) =>
            {
                callback(instance);
            });
        }

        /// <summary>
        /// Register a new resolving callback.
        /// <para>Only the type matches the given type will be called back.</para>
        /// </summary>
        /// <typeparam name="T">The specified type.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="closure">The closure.</param>
        /// <returns>Returns the <see cref="IContainer"/> instance.</returns>
        public static IContainer OnResolving<T>(this IContainer container, Action<T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return container.OnResolving((_, instance) =>
            {
                if (instance is T)
                {
                    closure((T)instance);
                }
            });
        }

        /// <summary>
        /// Register a new resolving callback.
        /// <para>Only the type matches the given type will be called back.</para>
        /// </summary>
        /// <typeparam name="T">The specified type.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="closure">The closure.</param>
        /// <returns>Returns the <see cref="IContainer"/> instance.</returns>
        public static IContainer OnResolving<T>(this IContainer container, Action<IBindData, T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return container.OnResolving((bindData, instance) =>
            {
                if (instance is T)
                {
                    closure(bindData, (T)instance);
                }
            });
        }

        /// <summary>
        /// Register a new after resolving callback.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="callback">The callback.</param>
        /// <returns>Returns the <see cref="IContainer"/> instance.</returns>
        public static IContainer OnAfterResolving(this IContainer container, Action<object> callback)
        {
            Guard.Requires<ArgumentNullException>(callback != null);
            return container.OnAfterResolving((_, instance) =>
            {
                callback(instance);
            });
        }

        /// <summary>
        /// Register a new after resolving callback.
        /// <para>Only the type matches the given type will be called back.</para>
        /// </summary>
        /// <typeparam name="T">The specified type.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="closure">The closure.</param>
        /// <returns>Returns the <see cref="IContainer"/> instance.</returns>
        public static IContainer OnAfterResolving<T>(this IContainer container, Action<T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return container.OnAfterResolving((_, instance) =>
            {
                if (instance is T)
                {
                    closure((T)instance);
                }
            });
        }

        /// <summary>
        /// Register a new after resolving callback.
        /// <para>Only the type matches the given type will be called back.</para>
        /// </summary>
        /// <typeparam name="T">The specified type.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="closure">The closure.</param>
        /// <returns>Returns the <see cref="IContainer"/> instance.</returns>
        public static IContainer OnAfterResolving<T>(this IContainer container, Action<IBindData, T> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            return container.OnAfterResolving((bindData, instance) =>
            {
                if (instance is T)
                {
                    closure(bindData, (T)instance);
                }
            });
        }

        /// <summary>
        /// Watch the specified service, trigger callback when rebinding the service.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The callback.</param>
        public static void Watch<TService>(this IContainer container, Action method)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            container.OnRebound(container.Type2Service(typeof(TService)), (instance) => method());
        }

        /// <summary>
        /// Watch the specified service, trigger callback when rebinding the service.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="method">The callback.</param>
        public static void Watch<TService>(this IContainer container, Action<TService> method)
        {
            Guard.Requires<ArgumentNullException>(method != null);
            container.OnRebound(container.Type2Service(typeof(TService)), (instance) => method((TService)instance));
        }

        /// <summary>
        /// Converts the given type to the service name.
        /// </summary>
        /// <typeparam name="TService">The given type.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <returns>The service name.</returns>
        public static string Type2Service<TService>(this IContainer container)
        {
            return container.Type2Service(typeof(TService));
        }

        /// <summary>
        /// Lazially resolve a service that is built when the call returns a callback.
        /// </summary>
        /// <typeparam name="TService">The service name.</typeparam>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The callback.</returns>
        public static Func<TService> Factory<TService>(this IContainer container, params object[] userParams)
        {
            return () => (TService)container.Make(container.Type2Service(typeof(TService)), userParams);
        }

        /// <summary>
        /// Lazially resolve a service that is built when the call returns a callback.
        /// </summary>
        /// <param name="container">The <see cref="IContainer"/> instance.</param>
        /// <param name="service">The service name or alias.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The callback.</returns>
        public static Func<object> Factory(this IContainer container, string service, params object[] userParams)
        {
            return () => container.Make(service, userParams);
        }
    }
}


================================================
FILE: src/CatLib.Core/Container/GivenData.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Util;
using System;

namespace CatLib.Container
{
    /// <inheritdoc />
    internal sealed class GivenData<TReturn> : IGivenData<TReturn>
        where TReturn : class, IBindable<TReturn>
    {
        private readonly Bindable<TReturn> bindable;
        private readonly Container container;
        private string needs;

        /// <summary>
        /// Initializes a new instance of the <see cref="GivenData{TReturn}"/> class.
        /// </summary>
        /// <param name="container">The container instance.</param>
        /// <param name="bindable">The bindable data.</param>
        internal GivenData(Container container, Bindable<TReturn> bindable)
        {
            this.container = container;
            this.bindable = bindable;
        }

        /// <inheritdoc />
        public TReturn Given(string service)
        {
            Guard.ParameterNotNull(service, nameof(service));

            bindable.AddContextual(needs, service);
            return bindable as TReturn;
        }

        /// <inheritdoc />
        public TReturn Given<TService>()
        {
            return Given(container.Type2Service(typeof(TService)));
        }

        /// <inheritdoc />
        public TReturn Given(Func<object> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null);
            bindable.AddContextual(needs, closure);
            return bindable as TReturn;
        }

        /// <inheritdoc cref="Bindable{TReturn}.Needs"/>
        internal IGivenData<TReturn> Needs(string needs)
        {
            this.needs = needs;
            return this;
        }
    }
}


================================================
FILE: src/CatLib.Core/Container/IBindData.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;

namespace CatLib.Container
{
    /// <summary>
    /// The bind data indicates relational data related to the specified service.
    /// </summary>
    public interface IBindData : IBindable<IBindData>
    {
        /// <summary>
        /// Gets the delegate return service concrete.
        /// </summary>
        Func<IContainer, object[], object> Concrete { get; }

        /// <summary>
        /// Gets a value indicating whether true if the service is singleton(static).
        /// </summary>
        bool IsStatic { get; }

        /// <summary>
        /// Alias service to a different name.
        /// </summary>
        /// <param name="alias">The alias.</param>
        /// <returns>The current instance.</returns>
#pragma warning disable CA1716
        IBindData Alias(string alias);
#pragma warning restore CA1716

        /// <summary>
        /// Assign a tag to a given service.
        /// </summary>
        /// <param name="tag">The tag name.</param>
        /// <returns>The current instance.</returns>
        IBindData Tag(string tag);

        /// <summary>
        /// Register a new resolving callback.
        /// </summary>
        /// <param name="closure">The resolving callback.</param>
        /// <returns>The current instance.</returns>
        IBindData OnResolving(Action<IBindData, object> closure);

        /// <summary>
        /// Register a new after resolving callback.
        /// </summary>
        /// <param name="closure">The after resolving callback.</param>
        /// <returns>The current instance.</returns>
        IBindData OnAfterResolving(Action<IBindData, object> closure);

        /// <summary>
        /// Register a new release callback.
        /// </summary>
        /// <param name="closure">The release callback.</param>
        /// <returns>The current instance.</returns>
        IBindData OnRelease(Action<IBindData, object> closure);
    }
}


================================================
FILE: src/CatLib.Core/Container/IBindable.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

#pragma warning disable SA1402

namespace CatLib.Container
{
    /// <summary>
    /// <see cref="IBindable"/> is the interface implemented by all bindable data classes.
    /// </summary>
    public interface IBindable
    {
        /// <summary>
        /// Gets the service name.
        /// </summary>
        string Service { get; }

        /// <summary>
        /// Gets the container to which the service belongs.
        /// </summary>
        IContainer Container { get; }

        /// <summary>
        /// Unbind the service from the container.
        /// </summary>
        /// <remarks>
        /// If the service is a singletoned instance, then the singleton instance
        /// that has been built will be automatically released.
        /// </remarks>
        void Unbind();
    }

    /// <inheritdoc />
    public interface IBindable<TReturn> : IBindable
        where TReturn : IBindable
    {
        /// <summary>
        /// When the service specified by the demand.
        /// </summary>
        /// <param name="service">The specified service name.</param>
        /// <returns>The given relationship in the context.</returns>
        IGivenData<TReturn> Needs(string service);

        /// <inheritdoc cref="Needs(string)"/>
        /// <typeparam name="TService">The type convert to service name.</typeparam>
        IGivenData<TReturn> Needs<TService>();
    }
}


================================================
FILE: src/CatLib.Core/Container/IContainer.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;
using System.Reflection;

#pragma warning disable CA1716

namespace CatLib.Container
{
    /// <summary>
    /// <see cref="IContainer"/> is the interface implemented by all IOC Container classes.
    /// </summary>
    public interface IContainer
    {
        /// <summary>
        /// Resolve the given type from the container.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <returns>The serivce instance. Throw exception if the service can not resolved.</returns>
        object this[string service] { get; set; }

        /// <summary>
        /// Gets the binding data of the given service.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <returns>Return null If there is no binding data.</returns>
        IBindData GetBind(string service);

        /// <summary>
        /// Whether the given service has been bound.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <returns>True if the service has been bound.</returns>
        bool HasBind(string service);

        /// <summary>
        /// Whether the existing instance is exists in the container.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <returns>True if the instance existed.</returns>
        bool HasInstance(string service);

        /// <summary>
        /// Whether the service has been resolved.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <returns>True if the service has been resolved.</returns>
        bool IsResolved(string service);

        /// <summary>
        /// Whether the given service can be made.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <returns>True if the given service can be made.</returns>
        bool CanMake(string service);

        /// <summary>
        /// Whether the given service is singleton bind. false if the service not exists.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <returns>True if the service is singleton bind.</returns>
        bool IsStatic(string service);

        /// <summary>
        /// Whether the given name is an alias.
        /// </summary>
        /// <param name="name">The given name.</param>
        /// <returns>True if the given name is an alias.</returns>
        bool IsAlias(string name);

        /// <summary>
        /// Register a binding with the container.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <param name="concrete">The service type.</param>
        /// <param name="isStatic">Whether the service is singleton bind.</param>
        /// <returns>The binding data.</returns>
        IBindData Bind(string service, Type concrete, bool isStatic);

        /// <summary>
        /// Register a binding with the container.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <param name="concrete">Closure return service instance.</param>
        /// <param name="isStatic">Whether the service is singleton bind.</param>
        /// <returns>The binding data.</returns>
        IBindData Bind(string service, Func<IContainer, object[], object> concrete, bool isStatic);

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <param name="concrete">Closure return service instance.</param>
        /// <param name="isStatic">Whether the service is singleton bind.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        bool BindIf(string service, Func<IContainer, object[], object> concrete, bool isStatic, out IBindData bindData);

        /// <summary>
        /// Register a binding with the container if the service not exists.
        /// </summary>
        /// <param name="service">The service name.</param>
        /// <param name="concrete">The service type.</param>
        /// <param name="isStatic">Whether the service is singleton bind.</param>
        /// <param name="bindData">The binding data.</param>
        /// <returns>True if register a binding with the container.</returns>
        bool BindIf(string service, Type concrete, bool isStatic, out IBindData bindData);

        /// <summary>
        /// Register a method with the container.
        /// </summary>
        /// <param name="method">The method name.</param>
        /// <param name="target">The invoking target.</param>
        /// <param name="called">The method info to invoke.</param>
        /// <returns>The method binding data.</returns>
        IMethodBind BindMethod(string method, object target, MethodInfo called);

        /// <summary>
        /// Unbinds a method from the container.
        /// </summary>
        /// <param name="target">
        /// The target.
        /// <para><code>string</code> will be taken as the method name.</para>
        /// <para><code>IMethodBind</code> will be taken as a given method.</para>
        /// <para>Other object will be taken as the invoking target.</para>
        /// </param>
        void UnbindMethod(object target);

        /// <summary>
        /// Unbinds a service from the container.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        void Unbind(string service);

        /// <summary>
        /// Assign a set of tags to a given binding.
        /// </summary>
        /// <param name="tag">The tag name.</param>
        /// <param name="services">The array of service name or alias.</param>
        void Tag(string tag, params string[] services);

        /// <summary>
        /// Resolve all of the bindings for a given tag.
        /// </summary>
        /// <param name="tag">The tag name.</param>
        /// <returns>All the services tagged with the given tag name.</returns>
        object[] Tagged(string tag);

        /// <summary>
        /// Register an existing instance as shared in the container.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <param name="instance">The service instance.</param>
        /// <returns>New instance after being processed by the decorator.</returns>
        object Instance(string service, object instance);

        /// <summary>
        /// Release an existing instance in the container.
        /// </summary>
        /// <param name="mixed">The service name or alias or instance.</param>
        /// <returns>True if the existing instance has been released.</returns>
        bool Release(object mixed);

        /// <summary>
        /// Flush the container of all bindings and resolved instances.
        /// </summary>
        void Flush();

        /// <summary>
        /// Call the method in bonded container and inject its dependencies.
        /// </summary>
        /// <param name="method">The method name.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The return value of method.</returns>
        object Invoke(string method, params object[] userParams);

        /// <summary>
        /// Call the given method and inject its dependencies.
        /// </summary>
        /// <param name="target">The instance on which to call the method.</param>
        /// <param name="methodInfo">The method info.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The return value of method.</returns>
        object Call(object target, MethodInfo methodInfo, params object[] userParams);

        /// <summary>
        /// Resolve the given service or alias from the container.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The serivce instance. Throw exception if the service can not resolved.</returns>
        object Make(string service, params object[] userParams);

        /// <summary>
        /// Alias a service to a different name.
        /// </summary>
        /// <param name="alias">The alias name to service.</param>
        /// <param name="service">The service name.</param>
        /// <returns>The container instance.</returns>
        IContainer Alias(string alias, string service);

        /// <summary>
        /// <see cref="Extend"/> an abstract type in the container.
        /// <para>Allow configuration or replacement of services during service resolving.</para>
        /// </summary>
        /// <param name="service">The service name or alias, null if the apply to gloabl.</param>
        /// <param name="closure">The closure replacement instance.</param>
        void Extend(string service, Func<object, IContainer, object> closure);

        /// <summary>
        /// Register a new resolving callback.
        /// </summary>
        /// <param name="closure">The callback.</param>
        /// <returns>The container instance.</returns>
        IContainer OnResolving(Action<IBindData, object> closure);

        /// <summary>
        /// Register a new after resolving callback.
        /// </summary>
        /// <param name="closure">The callback.</param>
        /// <returns>The container instance.</returns>
        IContainer OnAfterResolving(Action<IBindData, object> closure);

        /// <summary>
        /// Register a new release callback.
        /// </summary>
        /// <param name="closure">The callback.</param>
        /// <returns>The container instance.</returns>
        IContainer OnRelease(Action<IBindData, object> closure);

        /// <summary>
        /// Register a callback for when type finding fails.
        /// </summary>
        /// <param name="func">The callback.</param>
        /// <param name="priority">The priority.</param>
        /// <returns>The container instance.</returns>
        IContainer OnFindType(Func<string, Type> func, int priority = int.MaxValue);

        /// <summary>
        /// Register a new callback to an abstract's rebind event.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <param name="callback">The callback.</param>
        /// <returns>The container instance.</returns>
        IContainer OnRebound(string service, Action<object> callback);

        /// <summary>
        /// Converts the given type to the service name.
        /// </summary>
        /// <param name="type">The given type.</param>
        /// <returns>The service name.</returns>
        string Type2Service(Type type);
    }
}


================================================
FILE: src/CatLib.Core/Container/IGivenData.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;

namespace CatLib.Container
{
    /// <summary>
    /// Indicates the given relationship in the context.
    /// </summary>
    /// <typeparam name="TReturn">The type of the <see cref="IBindable"/>.</typeparam>
    public interface IGivenData<TReturn>
        where TReturn : IBindable
    {
        /// <summary>
        /// Give the specified service.
        /// </summary>
        /// <param name="service">The service name or alias.</param>
        /// <returns>The instance of the <see cref="IBindData"/>.</returns>
        TReturn Given(string service);

        /// <inheritdoc cref="Given(string)"/>
        TReturn Given<TService>();

        /// <inheritdoc cref="Given(string)"/>
        /// <param name="closure">The closure returns the given instance.</param>
        TReturn Given(Func<object> closure);
    }
}


================================================
FILE: src/CatLib.Core/Container/IMethodBind.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib.Container
{
    /// <summary>
    /// The method binding data.
    /// </summary>
    public interface IMethodBind : IBindable<IMethodBind>
    {
    }
}


================================================
FILE: src/CatLib.Core/Container/IParams.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib.Container
{
    /// <summary>
    /// All parameter tables must implement this interface.
    /// </summary>
    public interface IParams
    {
        /// <summary>
        /// Get parameters by name.
        /// </summary>
        /// <param name="key">The parameter name.</param>
        /// <param name="value">The parameter value.</param>
        /// <returns>True if the parameter exist.</returns>
        bool TryGetValue(string key, out object value);
    }
}


================================================
FILE: src/CatLib.Core/Container/InjectAttribute.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;

namespace CatLib.Container
{
    /// <summary>
    /// The injection attribute.
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public class InjectAttribute : Attribute
    {
        /// <summary>
        /// Gets or sets a value indicating whether the property is required.
        /// </summary>
        public bool Required { get; set; } = true;
    }
}


================================================
FILE: src/CatLib.Core/Container/MethodBind.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System.Reflection;

namespace CatLib.Container
{
    /// <summary>
    /// The default method binding data implementation.
    /// </summary>
    internal sealed class MethodBind : Bindable<IMethodBind>, IMethodBind
    {
        private readonly MethodContainer methodContainer;

        /// <summary>
        /// Initializes a new instance of the <see cref="MethodBind"/> class.
        /// </summary>
        /// <param name="methodContainer">The <see cref="MethodContainer"/> instance.</param>
        /// <param name="container">The <see cref="Container"/> instance.</param>
        /// <param name="service">The service name.</param>
        /// <param name="target">The instance on which to call the method.</param>
        /// <param name="call">The method to called.</param>
        public MethodBind(MethodContainer methodContainer, Container container, string service, object target, MethodInfo call)
            : base(container, service)
        {
            this.methodContainer = methodContainer;
            Target = target;
            MethodInfo = call;
            ParameterInfos = call.GetParameters();
        }

        /// <summary>
        /// Gets the method info.
        /// </summary>
        public MethodInfo MethodInfo { get; }

        /// <summary>
        /// Gets the instance on which to call the method.
        /// </summary>
        public object Target { get; }

        /// <summary>
        /// Gets an array of the method parameters.
        /// </summary>
        public ParameterInfo[] ParameterInfos { get; }

        /// <summary>
        /// Unbinds a method from the container.
        /// </summary>
        protected override void ReleaseBind()
        {
            methodContainer.Unbind(this);
        }
    }
}


================================================
FILE: src/CatLib.Core/Container/MethodContainer.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using CatLib.Util;
using System;
using System.Collections.Generic;
using System.Reflection;

namespace CatLib.Container
{
    /// <summary>
    /// The catlib ioc method container implemented.
    /// </summary>
    internal sealed class MethodContainer
    {
        private readonly Dictionary<object, List<string>> targetToMethodsMappings;
        private readonly Dictionary<string, MethodBind> methodMappings;
        private readonly Container container;

        /// <summary>
        /// Initializes a new instance of the <see cref="MethodContainer"/> class.
        /// </summary>
        /// <param name="container">The <see cref="Container"/> instance.</param>
        internal MethodContainer(Container container)
        {
            this.container = container;
            targetToMethodsMappings = new Dictionary<object, List<string>>();
            methodMappings = new Dictionary<string, MethodBind>();
        }

        /// <summary>
        /// Register a method with the container.
        /// </summary>
        /// <param name="method">The method name.</param>
        /// <param name="target">The invoking target.</param>
        /// <param name="methodInfo">The method info to invoke.</param>
        /// <returns>The method binding data.</returns>
        public IMethodBind Bind(string method, object target, MethodInfo methodInfo)
        {
            Guard.ParameterNotNull(method, nameof(method));
            Guard.ParameterNotNull(methodInfo, nameof(methodInfo));

            if (!methodInfo.IsStatic)
            {
                Guard.Requires<ArgumentNullException>(target != null);
            }

            if (methodMappings.ContainsKey(method))
            {
                throw new LogicException($"Method [{method}] is already {nameof(Bind)}");
            }

            var methodBind = new MethodBind(this, container, method, target, methodInfo);
            methodMappings[method] = methodBind;

            if (target == null)
            {
                return methodBind;
            }

            if (!targetToMethodsMappings.TryGetValue(target, out List<string> targetMappings))
            {
                targetToMethodsMappings[target] = targetMappings = new List<string>();
            }

            targetMappings.Add(method);
            return methodBind;
        }

        /// <summary>
        /// Call the method in bonded container and inject its dependencies.
        /// </summary>
        /// <param name="method">The method name.</param>
        /// <param name="userParams">The user parameters.</param>
        /// <returns>The return value of method.</returns>
        public object Invoke(string method, params object[] userParams)
        {
            Guard.ParameterNotNull(method, nameof(method));

            if (!methodMappings.TryGetValue(method, out MethodBind methodBind))
            {
                throw MakeMethodNotFoundException(method);
            }

            var injectParams = container.GetDependencies(methodBind, methodBind.ParameterInfos, userParams) ??
                               Array.Empty<object>();
            return methodBind.MethodInfo.Invoke(methodBind.Target, injectParams);
        }

        /// <summary>
        /// Unbinds a method from the container.
        /// </summary>
        /// <param name="target">
        /// The target.
        /// <para><code>string</code> will be taken as the method name.</para>
        /// <para><code>IMethodBind</code> will be taken as a given method.</para>
        /// <para>Other object will be taken as the invoking target.</para>
        /// </param>
        public void Unbind(object target)
        {
            Guard.Requires<ArgumentNullException>(target != null);

            if (target is MethodBind methodBind)
            {
                methodBind.Unbind();
                return;
            }

            if (target is string)
            {
                if (!methodMappings.TryGetValue(target.ToString(), out methodBind))
                {
                    return;
                }

                methodBind.Unbind();
                return;
            }

            UnbindWithObject(target);
        }

        /// <summary>
        /// Flush the container of all method bindings.
        /// </summary>
        public void Flush()
        {
            targetToMethodsMappings.Clear();
            methodMappings.Clear();
        }

        /// <summary>
        /// Unbinds a method from the container.
        /// </summary>
        /// <param name="methodBind">The method binding data.</param>
        internal void Unbind(MethodBind methodBind)
        {
            methodMappings.Remove(methodBind.Service);

            if (methodBind.Target == null)
            {
                return;
            }

            if (!targetToMethodsMappings.TryGetValue(methodBind.Target, out List<string> methods))
            {
                return;
            }

            methods.Remove(methodBind.Service);

            if (methods.Count <= 0)
            {
                targetToMethodsMappings.Remove(methodBind.Target);
            }
        }

        /// <summary>
        /// Create a method without not found exception.
        /// </summary>
        private static LogicException MakeMethodNotFoundException(string method)
        {
            return new LogicException($"Method [{method}] is not found.");
        }

        /// <summary>
        /// Remove all methods bound to the object.
        /// </summary>
        private void UnbindWithObject(object target)
        {
            if (!targetToMethodsMappings.TryGetValue(target, out List<string> methods))
            {
                return;
            }

            foreach (var method in methods.ToArray())
            {
                Unbind(method);
            }
        }
    }
}


================================================
FILE: src/CatLib.Core/Container/ParamsCollection.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

namespace CatLib.Container
{
    /// <summary>
    /// Default parameter table implementation.
    /// </summary>
    [ExcludeFromCodeCoverage]
    public sealed class ParamsCollection : IParams, IEnumerable<KeyValuePair<string, object>>
    {
        private readonly IDictionary<string, object> collection;

        /// <summary>
        /// Initializes a new instance of the <see cref="ParamsCollection"/> class.
        /// </summary>
        public ParamsCollection()
        {
            collection = new Dictionary<string, object>();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ParamsCollection"/> class.
        /// </summary>
        /// <param name="mapping">The parameters mapping.</param>
        public ParamsCollection(IDictionary<string, object> mapping)
        {
            collection = mapping;
        }

        /// <summary>
        /// Get or set a parameter.
        /// </summary>
        /// <param name="key">The parameter name.</param>
        /// <returns>The parameter value.</returns>
        public object this[string key]
        {
            get => collection[key];
            set => collection[key] = value;
        }

        /// <summary>
        /// Gets the iterator.
        /// </summary>
        /// <returns>Return the iterator.</returns>
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return collection.GetEnumerator();
        }

        /// <summary>
        /// Gets the iterator.
        /// </summary>
        /// <returns>Return the iterator.</returns>
        IEnumerator<KeyValuePair<string, object>> IEnumerable<KeyValuePair<string, object>>.GetEnumerator()
        {
            return collection.GetEnumerator();
        }

        /// <summary>
        /// Add an parameter.
        /// </summary>
        /// <param name="key">The parameter name.</param>
        /// <param name="value">The parameter value.</param>
        public void Add(string key, object value)
        {
            collection.Add(key, value);
        }

        /// <summary>
        /// Remove an parameter.
        /// </summary>
        /// <param name="key">The parameter name.</param>
        /// <returns>True if the removed.</returns>
        public bool Remove(string key)
        {
            return collection.Remove(key);
        }

        /// <summary>
        /// Gets an parameter value.
        /// </summary>
        /// <param name="key">The parameter name.</param>
        /// <param name="value">The parameter value.</param>
        /// <returns>True if the parameter is exist.</returns>
        public bool TryGetValue(string key, out object value)
        {
            return collection.TryGetValue(key, out value);
        }
    }
}


================================================
FILE: src/CatLib.Core/Container/UnresolvableException.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using System.Diagnostics.CodeAnalysis;
using SException = System.Exception;

namespace CatLib.Container
{
    /// <summary>
    /// Failed to resolve the service exception.
    /// </summary>
    [ExcludeFromCodeCoverage]
    public class UnresolvableException : RuntimeException
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="UnresolvableException"/> class.
        /// </summary>
        public UnresolvableException()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="UnresolvableException"/> class.
        /// </summary>
        /// <param name="message">The exception message.</param>
        public UnresolvableException(string message)
            : base(message)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="UnresolvableException"/> class.
        /// </summary>
        /// <param name="message">The exception message.</param>
        /// <param name="innerException">The inner exception.</param>
        public UnresolvableException(string message, SException innerException)
            : base(message, innerException)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core/Container/VariantAttribute.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;

namespace CatLib.Container
{
    /// <summary>
    /// A constructor that represents the class allows a primitive type(Include string) to be passed in to be converted to the current class.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class)]
    public class VariantAttribute : Attribute
    {
    }
}


================================================
FILE: src/CatLib.Core/EventDispatcher/EventDispatcher.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using CatLib.Util;
using System;
using System.Collections.Generic;
using System.Linq;

namespace CatLib.EventDispatcher
{
    /// <inheritdoc />
    public class EventDispatcher : IEventDispatcher
    {
        private readonly IDictionary<string, IList<EventHandler>> listeners;

        /// <summary>
        /// Initializes a new instance of the <see cref="EventDispatcher"/> class.
        /// </summary>
        public EventDispatcher()
        {
            listeners = new Dictionary<string, IList<EventHandler>>();
        }

        /// <inheritdoc />
        public virtual bool AddListener(string eventName, EventHandler handler)
        {
            if (string.IsNullOrEmpty(eventName) || handler == null)
            {
                return false;
            }

            if (!listeners.TryGetValue(eventName, out IList<EventHandler> handlers))
            {
                listeners[eventName] = handlers = new List<EventHandler>();
            }
            else if (handlers.Contains(handler))
            {
                return false;
            }

            handlers.Add(handler);
            return true;
        }

        /// <inheritdoc />
        public virtual void Raise(string eventName, object sender, EventArgs e = null)
        {
            Guard.Requires<LogicException>(!(sender is EventArgs), $"Passed event args for the parameter {sender}, Did you make a wrong method call?");

            e = e ?? EventArgs.Empty;
            if (!listeners.TryGetValue(eventName, out IList<EventHandler> handlers))
            {
                return;
            }

            foreach (var listener in handlers)
            {
                if (e is IStoppableEvent stoppableEvent
                    && stoppableEvent.IsPropagationStopped)
                {
                    break;
                }

                listener(sender, e);
            }
        }

        /// <inheritdoc />
        public virtual EventHandler[] GetListeners(string eventName)
        {
            if (!listeners.TryGetValue(eventName, out IList<EventHandler> handlers))
            {
                return Array.Empty<EventHandler>();
            }

            return handlers.ToArray();
        }

        /// <inheritdoc />
        public virtual bool HasListener(string eventName)
        {
            return listeners.ContainsKey(eventName);
        }

        /// <inheritdoc />
        public virtual bool RemoveListener(string eventName, EventHandler handler = null)
        {
            if (handler == null)
            {
                return listeners.Remove(eventName);
            }

            if (!listeners.TryGetValue(eventName, out IList<EventHandler> handlers))
            {
                return false;
            }

            var status = handlers.Remove(handler);
            if (handlers.Count <= 0)
            {
                listeners.Remove(eventName);
            }

            return status;
        }
    }
}


================================================
FILE: src/CatLib.Core/EventDispatcher/IEventDispatcher.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;

namespace CatLib.EventDispatcher
{
    /// <summary>
    /// Represents an event dispatcher.
    /// </summary>
    public interface IEventDispatcher
    {
        /// <summary>
        /// Adds an event listener that listens on the specified events.
        /// </summary>
        /// <param name="eventName">The event name.</param>
        /// <param name="handler">The event listener.</param>
        /// <returns>True if the handler added. otherwise false if handler already exists.</returns>
        bool AddListener(string eventName, EventHandler handler);

        /// <summary>
        /// Removes an event listener from the specified events.
        /// </summary>
        /// <param name="eventName">The event name.</param>
        /// <param name="handler">Remove the specified event listener, otherwise remove all listeners under the event.</param>
        /// <returns>True if removed the listener.</returns>
        bool RemoveListener(string eventName, EventHandler handler = null);

        /// <summary>
        /// Gets the listeners of a specific event or all listeners sorted by descending priority. Will not return listeners in the inheritance chain.
        /// </summary>
        /// <typeparam name="T">The specified events type.</typeparam>
        /// <param name="eventName">The event name.</param>
        /// <returns>The event listeners for the specified event. Never return null.</returns>
        EventHandler[] GetListeners(string eventName);

        /// <summary>
        /// Whether an event has any registered event listener.
        /// If has inheritance, will not return handler in the inheritance chain.
        /// </summary>
        /// <param name="eventName">The event name.</param>
        /// <returns>True if the event has any registered listeners.</returns>
        bool HasListener(string eventName);

        /// <summary>
        /// Provide all relevant listeners with an event to process.
        /// </summary>
        /// <param name="eventName">The event name.</param>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The event object to process.</param>
#pragma warning disable CA1030
        void Raise(string eventName, object sender, EventArgs e = null);
#pragma warning restore CA1030
    }
}


================================================
FILE: src/CatLib.Core/EventDispatcher/IStoppableEvent.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib.EventDispatcher
{
    /// <summary>
    /// An event whose processing may be interrupted when the event has been handled.
    /// </summary>
    public interface IStoppableEvent
    {
        /// <summary>
        /// Gets a value indicating whether propagation stopped.
        /// </summary>
        /// <returns>True if the propagation stopped.</returns>
        bool IsPropagationStopped { get; }
    }
}


================================================
FILE: src/CatLib.Core/Exception/AssertException.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System.Diagnostics.CodeAnalysis;
using System.Runtime.Serialization;
using SException = System.Exception;

namespace CatLib.Exception
{
    /// <summary>
    /// Represents an assertion exception.
    /// </summary>
    [ExcludeFromCodeCoverage]
    public class AssertException : RuntimeException
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="AssertException"/> class.
        /// </summary>
        public AssertException()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AssertException"/> class.
        /// </summary>
        /// <param name="message">The exception message.</param>
        public AssertException(string message)
            : base(message)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AssertException"/> class.
        /// </summary>
        /// <param name="message">The exception message.</param>
        /// <param name="innerException">The inner exception.</param>
        public AssertException(string message, SException innerException)
            : base(message, innerException)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AssertException"/> class.
        /// </summary>
        /// <param name="serializationInfo">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
        /// <param name="streamingContext">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
        protected AssertException(SerializationInfo serializationInfo, StreamingContext streamingContext)
            : base(serializationInfo, streamingContext)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core/Exception/LogicException.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System.Diagnostics.CodeAnalysis;
using System.Runtime.Serialization;
using SException = System.Exception;

namespace CatLib.Exception
{
    /// <summary>
    /// Represents a logical exception encountered during execution.
    /// </summary>
    /// <remarks>Logical exceptions are caused by logical errors during runtime.</remarks>
    [ExcludeFromCodeCoverage]
    public class LogicException : RuntimeException
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="LogicException"/> class.
        /// </summary>
        public LogicException()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="LogicException"/> class.
        /// </summary>
        /// <param name="message">The exception message.</param>
        public LogicException(string message)
            : base(message)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="LogicException"/> class.
        /// </summary>
        /// <param name="message">The exception message.</param>
        /// <param name="innerException">The inner exception.</param>
        public LogicException(string message, SException innerException)
            : base(message, innerException)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="LogicException"/> class.
        /// </summary>
        /// <param name="serializationInfo">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
        /// <param name="streamingContext">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
        protected LogicException(SerializationInfo serializationInfo, StreamingContext streamingContext)
            : base(serializationInfo, streamingContext)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core/Exception/RuntimeException.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System.Runtime.Serialization;
using SException = System.Exception;

namespace CatLib.Exception
{
    /// <summary>
    /// Represents a generic runtime exception.
    /// </summary>
    public class RuntimeException : SException
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RuntimeException"/> class.
        /// </summary>
        public RuntimeException()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RuntimeException"/> class.
        /// </summary>
        /// <param name="message">The exception message.</param>
        public RuntimeException(string message)
            : base(message)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RuntimeException"/> class.
        /// </summary>
        /// <param name="message">The exception message.</param>
        /// <param name="innerException">The inner exception.</param>
        public RuntimeException(string message, SException innerException)
            : base(message, innerException)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RuntimeException"/> class.
        /// </summary>
        /// <param name="serializationInfo">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
        /// <param name="streamingContext">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
        protected RuntimeException(SerializationInfo serializationInfo, StreamingContext streamingContext)
            : base(serializationInfo, streamingContext)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core/IO/CombineStream.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using CatLib.Util;
using System;
using System.IO;

namespace CatLib.IO
{
    /// <summary>
    /// <see cref="CombineStream"/> allow multiple different streams to be combined into one stream.
    /// </summary>
    public class CombineStream : Stream
    {
        /// <summary>
        /// An array of multiple streams.
        /// </summary>
        private readonly Stream[] streams;

        /// <summary>
        /// Whether to close the sub stream when closing the combined stream.
        /// </summary>
        private readonly bool autoClosed;

        /// <summary>
        /// Indicates the position of the current cursor.
        /// </summary>
        private long globalPosition;

        /// <summary>
        /// Indicates the index of the current stream.
        /// </summary>
        private int index;

        /// <summary>
        /// The length of the <see cref="CombineStream"/>.
        /// </summary>
        private long length;

        /// <summary>
        /// Initializes a new instance of the <see cref="CombineStream"/> class.
        /// </summary>
        /// <param name="left">The left stream.</param>
        /// <param name="right">The right stream.</param>
        /// <param name="closed">Whether to close the sub stream when closing the combined stream.</param>
        public CombineStream(Stream left, Stream right, bool closed = false)
            : this(new[] { left, right }, closed)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CombineStream"/> class.
        /// </summary>
        /// <param name="source">An array of the sub stream.</param>
        /// <param name="closed">Whether to close the sub stream when closing the combined stream.</param>
        public CombineStream(Stream[] source, bool closed = false)
        {
            index = 0;
            streams = source;
            length = -1;
            autoClosed = closed;
        }

        /// <summary>
        /// Gets the length of the <see cref="CombineStream"/>.
        /// </summary>
        public override long Length
        {
            get
            {
                if (length >= 0)
                {
                    return length;
                }

                length = 0;
                foreach (var stream in streams)
                {
                    length += stream.Length;
                }

                return length;
            }
        }

        /// <inheritdoc />
        public override bool CanSeek
        {
            get
            {
                foreach (var stream in streams)
                {
                    if (!stream.CanSeek)
                    {
                        return false;
                    }
                }

                return true;
            }
        }

        /// <inheritdoc />
        public override long Position
        {
            get => globalPosition;
            set => Seek(value, SeekOrigin.Begin);
        }

        /// <inheritdoc />
        public override bool CanRead
        {
            get
            {
                foreach (var stream in streams)
                {
                    if (!stream.CanRead)
                    {
                        return false;
                    }
                }

                return true;
            }
        }

        /// <inheritdoc />
        public override bool CanWrite => false;

        /// <inheritdoc />
        public override long Seek(long offset, SeekOrigin origin)
        {
            if (!CanSeek)
            {
                throw new NotSupportedException($"{nameof(CombineStream)} not supported {nameof(Seek)}.");
            }

            long newGloablPosition;
            switch (origin)
            {
                case SeekOrigin.Begin:
                    newGloablPosition = offset;
                    break;
                case SeekOrigin.Current:
                    newGloablPosition = globalPosition + offset;
                    break;
                case SeekOrigin.End:
                    newGloablPosition = Length + offset;
                    break;
                default:
                    throw new NotSupportedException($"Not support {nameof(SeekOrigin)}: {origin}");
            }

            if (newGloablPosition < 0 || newGloablPosition > Length)
            {
                throw new ArgumentOutOfRangeException($"{nameof(offset)} must large than zero or small then {nameof(Length)}");
            }

            long localPosition = 0;
            var newIndex = index = CalculatedIndex(newGloablPosition, ref localPosition);

            streams[newIndex].Seek(localPosition, SeekOrigin.Begin);
            while (++newIndex < streams.Length)
            {
                streams[newIndex].Seek(0, SeekOrigin.Begin);
            }

            return globalPosition = newGloablPosition;
        }

        /// <inheritdoc />
        public override int Read(byte[] buffer, int offset, int count)
        {
            Guard.Requires<ArgumentNullException>(buffer != null);
            Guard.Requires<ArgumentOutOfRangeException>(offset >= 0);
            Guard.Requires<ArgumentOutOfRangeException>(count >= 0);
            Guard.Requires<ArgumentOutOfRangeException>(buffer.Length - offset >= count);

            var result = 0;
            do
            {
                var read = streams[index].Read(buffer, offset, count);
                if (read <= 0 && index < streams.Length - 1)
                {
                    index++;
                    continue;
                }

                if (read <= 0)
                {
                    break;
                }

                count -= read;
                offset += read;
                globalPosition += read;
                result += read;
            }
            while (count > 0);

            return result;
        }

        /// <inheritdoc />
        public override void Write(byte[] buffer, int offset, int count)
        {
            throw new NotSupportedException($"{nameof(CombineStream)} not supported {nameof(Write)}.");
        }

        /// <inheritdoc />
        public override void SetLength(long value)
        {
            throw new NotSupportedException($"{nameof(CombineStream)} not supported {nameof(SetLength)}.");
        }

        /// <inheritdoc />
        public override void Flush()
        {
            throw new NotSupportedException($"{nameof(CombineStream)} not supported {nameof(Flush)}.");
        }

        /// <summary>
        /// Calculate sub stream index and relative positions.
        /// </summary>
        /// <param name="globalPosition">The position of the current cursor.</param>
        /// <param name="localPosition">The relative position.</param>
        /// <returns>The index of the stream array.</returns>
        protected int CalculatedIndex(long globalPosition, ref long localPosition)
        {
            long len = 0;
            for (var i = 0; i < streams.Length; i++)
            {
                len += streams[i].Length;
                if (globalPosition > len)
                {
                    continue;
                }

                localPosition = streams[i].Length - (len - globalPosition);
                return i;
            }

            throw new AssertException($"Failed to determine {nameof(localPosition)}");
        }

        /// <inheritdoc />
        protected override void Dispose(bool disposing)
        {
            try
            {
                if (!autoClosed)
                {
                    return;
                }

                foreach (var stream in streams)
                {
                    stream?.Dispose();
                }
            }
            finally
            {
                base.Dispose(disposing);
            }
        }
    }
}


================================================
FILE: src/CatLib.Core/IO/RingBufferStream.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using CatLib.Util;
using System;
using System.IO;

namespace CatLib.IO
{
    /// <summary>
    /// Represents a ring buffer.
    /// </summary>
    public class RingBufferStream : Stream
    {
        private readonly long capacity;
        private readonly byte[] buffer;
        private readonly bool exposable;
        private readonly long mask;
        private long write;
        private long read;

        /// <summary>
        /// Initializes a new instance of the <see cref="RingBufferStream"/> class.
        /// </summary>
        /// <param name="capacity">Capacity, need to be the power of 2 (upward).</param>
        /// <param name="exposable">Whether possible to access internal arrays.</param>
        public RingBufferStream(int capacity = 8192, bool exposable = true)
        {
            Guard.Requires<ArgumentOutOfRangeException>(capacity > 0);
            this.capacity = ToPrime(capacity);
            buffer = new byte[this.capacity];
            mask = this.capacity - 1;
            write = 0;
            read = 0;
            this.exposable = exposable;
        }

        /// <summary>
        /// Gets the capacity of the ring buffer.
        /// </summary>
        public int Capacity => (int)capacity;

        /// <summary>
        /// Gets writeable count.
        /// </summary>
        public int WriteableCount => (int)GetCanWriteSize();

        /// <summary>
        /// Gets readable count.
        /// </summary>
        public int ReadableCount => (int)GetCanReadSize();

        /// <inheritdoc />
        public override bool CanRead => true;

        /// <inheritdoc />
        public override bool CanSeek => false;

        /// <inheritdoc />
        public override bool CanWrite => true;

        /// <inheritdoc />
        public override long Length => write;

        /// <inheritdoc />
        public override long Position { get => read; set => Seek(value, SeekOrigin.Begin); }

        /// <summary>
        /// Gets the original array of ring buffer.
        /// </summary>
        /// <returns>Returns the original array of ring buffer.</returns>
        public byte[] GetBuffer()
        {
            if (!exposable)
            {
                throw new UnauthorizedAccessException("Unable to access original array");
            }

            return buffer;
        }

        /// <inheritdoc />
        public override int Read(byte[] buffer, int offset, int count)
        {
            var readSize = Peek(buffer, offset, count);
            read += readSize;
            return readSize;
        }

        /// <inheritdoc />
        public override void Write(byte[] buffer, int offset, int count)
        {
            Guard.Requires<ArgumentNullException>(buffer != null);
            Guard.Requires<ArgumentOutOfRangeException>(offset >= 0);
            Guard.Requires<ArgumentOutOfRangeException>(count >= 0);
            Guard.Requires<ArgumentOutOfRangeException>((buffer.Length - offset) >= count);

            var writeSize = GetCanWriteSize();

            if (writeSize < count)
            {
                throw new RuntimeException("The memory is no longer writable because the buffer area is full.");
            }

            if (writeSize > count)
            {
                writeSize = count;
            }

            if (writeSize <= 0)
            {
                return;
            }

            var nextWritePos = write + writeSize;
            var realWritePos = write & mask;
            var realNextWritePos = nextWritePos & mask;

            if (realNextWritePos >= realWritePos)
            {
                Buffer.BlockCopy(buffer, offset, this.buffer, (int)realWritePos, (int)writeSize);
            }
            else
            {
                var tail = (int)(capacity - realWritePos);
                Buffer.BlockCopy(buffer, offset, this.buffer, (int)realWritePos, tail);

                if ((writeSize - tail) > 0)
                {
                    Buffer.BlockCopy(buffer, offset + tail, this.buffer, 0, (int)writeSize - tail);
                }
            }

            write = nextWritePos;
        }

        /// <summary>
        /// Read the data of the ring buffer into <paramref name="buffer"/>,
        /// but do not advance the read position.
        /// </summary>
        /// <param name="buffer">The read data is filled into the current buffer.</param>
        /// <param name="offset">The starting offset of the buffer array.</param>
        /// <param name="count">How many lengths of data expected to read.</param>
        /// <returns>Actual read length.</returns>
        public int Peek(byte[] buffer, int offset, int count)
        {
            Guard.Requires<ArgumentNullException>(buffer != null);
            Guard.Requires<ArgumentOutOfRangeException>(offset >= 0);
            Guard.Requires<ArgumentOutOfRangeException>(count >= 0);
            Guard.Requires<ArgumentOutOfRangeException>((buffer.Length - offset) >= count);

            var readSize = GetCanReadSize();
            if (readSize > count)
            {
                readSize = count;
            }

            if (readSize <= 0)
            {
                return 0;
            }

            var nextReadPos = read + readSize;

            var realReadPos = read & mask;
            var realNextReadPos = nextReadPos & mask;

            if (realNextReadPos >= realReadPos)
            {
                Buffer.BlockCopy(this.buffer, (int)realReadPos, buffer, offset, (int)readSize);
            }
            else
            {
                var tail = (int)(capacity - realReadPos);
                Buffer.BlockCopy(this.buffer, (int)realReadPos, buffer, offset, tail);

                if (readSize - tail > 0)
                {
                    Buffer.BlockCopy(this.buffer, 0, buffer, offset + tail, (int)readSize - tail);
                }
            }

            return (int)readSize;
        }

        /// <summary>
        /// Clear the ring buffer.
        /// </summary>
        public void Clear()
        {
            write = 0;
            read = 0;
            Array.Clear(buffer, 0, buffer.Length);
        }

        /// <inheritdoc />
        public override void Flush()
        {
            // ignore.
        }

        /// <inheritdoc />
        public override long Seek(long offset, SeekOrigin origin)
        {
            throw new NotSupportedException();
        }

        /// <inheritdoc />
        public override void SetLength(long value)
        {
            throw new NotSupportedException();
        }

        /// <inheritdoc />
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                Clear();
            }

            base.Dispose(disposing);
        }

        /// <summary>
        /// Get the size of the byte stream that can be read.
        /// </summary>
        /// <returns>todo:1.</returns>
        private long GetCanReadSize()
        {
            return write - read;
        }

        /// <summary>
        /// Get the size of the byte stream that can be written.
        /// </summary>
        private long GetCanWriteSize()
        {
            return Math.Max(0, capacity - GetCanReadSize());
        }

        /// <summary>
        /// Calculate the power of the nearest two.
        /// </summary>
        /// <param name="min">The starting number.</param>
        /// <returns>The  power of the nearest two.</returns>
        private int ToPrime(int min)
        {
            min = Math.Max(0, min);

            var result = 0;
            for (var i = 2; i < int.MaxValue; i <<= 1)
            {
                if (i < min)
                {
                    continue;
                }

                result = i;
                break;
            }

            return result;
        }
    }
}


================================================
FILE: src/CatLib.Core/IO/SegmentStream.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;
using System.IO;

namespace CatLib.IO
{
    /// <summary>
    /// A <see cref="SegmentStream"/> can be used to wrap a stream of a specified slice。
    /// Make the stream of the specified shard access like the traditional
    /// stream from the beginning to the end。.
    /// </summary>
    public class SegmentStream : WrapperStream
    {
        /// <summary>
        /// The initial position of the base stream.
        /// </summary>
        private readonly long initialPosition;

        /// <summary>
        /// The slice size.
        /// </summary>
        private readonly long partSize;

        /// <summary>
        /// Initializes a new instance of the <see cref="SegmentStream"/> class.
        /// </summary>
        /// <param name="stream">The base stream.</param>
        /// <param name="partSize">The slice size.</param>
        public SegmentStream(Stream stream, long partSize = 0)
            : base(stream)
        {
            if (!stream.CanSeek)
            {
                throw new InvalidOperationException($"Base stream of {nameof(SegmentStream)} must be seekable");
            }

            initialPosition = stream.Position;
            var remainingSize = stream.Length - stream.Position;

            if (partSize == 0 || remainingSize < partSize)
            {
                this.partSize = remainingSize;
            }
            else
            {
                this.partSize = partSize;
            }
        }

        /// <inheritdoc />
        public override long Length
        {
            get
            {
                var length = base.Length - initialPosition;
                if (length > partSize)
                {
                    length = partSize;
                }

                return length;
            }
        }

        /// <inheritdoc />
        public override long Position
        {
            get => base.Position - initialPosition;
            set => base.Position = value;
        }

        /// <summary>
        /// Gets the remaining size.
        /// </summary>
        private long RemainingSize => partSize - Position;

        /// <inheritdoc />
        public override long Seek(long offset, SeekOrigin origin)
        {
            long position;
            switch (origin)
            {
                case SeekOrigin.Begin:
                    position = initialPosition + offset;
                    break;
                case SeekOrigin.Current:
                    position = base.Position + offset;
                    break;
                case SeekOrigin.End:
                    position = base.Position + partSize + offset;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(origin), origin, null);
            }

            if (position < initialPosition)
            {
                position = initialPosition;
            }
            else if (position > initialPosition + partSize)
            {
                position = initialPosition + partSize;
            }

            base.Seek(position, SeekOrigin.Begin);
            return Position;
        }

        /// <inheritdoc />
        public override int Read(byte[] buffer, int offset, int count)
        {
            var bytesToRead = count < RemainingSize ? count : (int)RemainingSize;
            return bytesToRead < 0 ? 0 : base.Read(buffer, offset, bytesToRead);
        }

        /// <inheritdoc />
        public override void SetLength(long value)
        {
            throw new NotSupportedException();
        }

        /// <inheritdoc />
        public override void Write(byte[] buffer, int offset, int count)
        {
            throw new NotSupportedException();
        }
    }
}


================================================
FILE: src/CatLib.Core/IO/StreamExtension.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using CatLib.Util;
using System;
using System.IO;
using System.Text;

namespace CatLib.IO
{
    /// <summary>
    /// The stream extension function.
    /// </summary>
    public static class StreamExtension
    {
        [ThreadStatic]
        private static byte[] buffer;

        private static byte[] Buffer
        {
            get
            {
                if (buffer == null)
                {
                    buffer = new byte[4096];
                }

                return buffer;
            }
        }

        /// <summary>
        /// Append the source stream to the destination stream.
        /// </summary>
        /// <param name="source">The source stream.</param>
        /// <param name="destination">The destination stream.</param>
        /// <returns>Byte length of transmitted data.</returns>
        public static long AppendTo(this Stream source, Stream destination)
        {
            return source.AppendTo(destination, Buffer);
        }

        /// <summary>
        /// Append the source stream to the destination stream.
        /// </summary>
        /// <param name="source">The source stream.</param>
        /// <param name="destination">The destination stream.</param>
        /// <param name="buffer">The buffer to use.</param>
        /// <returns>Byte length of transmitted data.</returns>
        public static long AppendTo(this Stream source, Stream destination, byte[] buffer)
        {
            Guard.Requires<ArgumentNullException>(source != null);
            Guard.Requires<ArgumentNullException>(destination != null);

            long result = 0;
            int read;
            while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
            {
                destination.Write(buffer, 0, read);
                result += read;
            }

            return result;
        }

        /// <summary>
        /// Read the stream's data and convert it to a string.
        /// </summary>
        /// <param name="source">The source stream.</param>
        /// <param name="encoding">The encoding for data.</param>
        /// <param name="closed">Whether auto closed stream.</param>
        /// <returns>The string.</returns>
        public static string ToText(this Stream source, Encoding encoding = null, bool closed = true)
        {
            Guard.Requires<ArgumentNullException>(source != null);
            try
            {
                if (!source.CanRead)
                {
                    throw new LogicException($"Can not read stream, {nameof(source.CanRead)} == false");
                }

                encoding = encoding ?? Encoding.Default;
                if (source is MemoryStream memoryStream)
                {
                    byte[] internalBuffer;
                    try
                    {
                        internalBuffer = memoryStream.GetBuffer();
                    }
                    catch (UnauthorizedAccessException)
                    {
                        internalBuffer = memoryStream.ToArray();
                    }

                    return encoding.GetString(internalBuffer, 0, (int)memoryStream.Length);
                }

                var length = 0;
                try
                {
                    length = (int)source.Length;
                }
                catch (NotSupportedException)
                {
                    // ignore
                }

                MemoryStream targetStream;
                if (length > 0 && length <= Buffer.Length)
                {
                    targetStream = new MemoryStream(Buffer, 0, Buffer.Length, true, true);
                }
                else
                {
                    targetStream = new MemoryStream(length);
                }

                using (targetStream)
                {
                    var read = source.AppendTo(targetStream);
                    return encoding.GetString(targetStream.GetBuffer(), 0, (int)read);
                }
            }
            finally
            {
                if (closed)
                {
                    source.Dispose();
                }
            }
        }

        /// <summary>
        /// Convert the specified string to a stream.
        /// </summary>
        /// <param name="str">The specified string.</param>
        /// <param name="encoding">The string encoding.</param>
        /// <returns>The stream instance.</returns>
        public static Stream ToStream(this string str, Encoding encoding = null)
        {
            return new MemoryStream((encoding ?? Encoding.Default).GetBytes(str));
        }
    }
}


================================================
FILE: src/CatLib.Core/IO/WrapperStream.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Util;
using System;
using System.Diagnostics.CodeAnalysis;
using System.IO;

namespace CatLib.IO
{
    /// <summary>
    /// The wrapper stream.
    /// </summary>
    [ExcludeFromCodeCoverage]
    public class WrapperStream : Stream
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="WrapperStream"/> class.
        /// </summary>
        public WrapperStream()
        {
            BaseStream = this;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="WrapperStream"/> class.
        /// </summary>
        /// <param name="stream">The base stream.</param>
        public WrapperStream(Stream stream)
        {
            Guard.Requires<ArgumentNullException>(stream != null);
            BaseStream = stream;
        }

        /// <summary>
        /// Gets the base stream.
        /// </summary>
        public Stream BaseStream { get; }

        /// <inheritdoc />
        public override bool CanRead => BaseStream.CanRead;

        /// <inheritdoc />
        public override bool CanSeek => BaseStream.CanSeek;

        /// <inheritdoc />
        public override bool CanWrite => BaseStream.CanWrite;

        /// <inheritdoc />
        public override long Position
        {
            get => BaseStream.Position;
            set => Seek(value, SeekOrigin.Begin);
        }

        /// <inheritdoc />
        public override long Length => BaseStream.Length;

        /// <inheritdoc />
        public override long Seek(long offset, SeekOrigin origin)
        {
            return BaseStream.Seek(offset, origin);
        }

        /// <inheritdoc />
        public override void Flush()
        {
            BaseStream.Flush();
        }

        /// <inheritdoc />
        public override void Write(byte[] buffer, int offset, int count)
        {
            BaseStream.Write(buffer, offset, count);
        }

        /// <inheritdoc />
        public override void SetLength(long value)
        {
            BaseStream.SetLength(value);
        }

        /// <inheritdoc />
        public override int Read(byte[] buffer, int offset, int count)
        {
            return BaseStream.Read(buffer, offset, count);
        }
    }
}


================================================
FILE: src/CatLib.Core/Properties/AssemblyInfo.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("CatLib.Core.Tests")]


================================================
FILE: src/CatLib.Core/Util/Arr.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using System;
using System.Collections.Generic;
using System.Linq;

namespace CatLib.Util
{
    /// <summary>
    /// Array helper.
    /// </summary>
    public static class Arr
    {
        /// <summary>
        /// Combine multiple specified arrays into one array.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <returns>Returns an merged array.</returns>
#pragma warning disable S2368
        public static T[] Merge<T>(params T[][] sources)
#pragma warning restore S2368
        {
            if (sources == null || sources.Length <= 0)
            {
                return Array.Empty<T>();
            }

            var totalSize = 0;
            foreach (var source in sources)
            {
                if (source == null || source.Length <= 0)
                {
                    continue;
                }

                totalSize += source.Length;
            }

            if (totalSize <= 0)
            {
                return Array.Empty<T>();
            }

            var merged = new T[totalSize];
            var length = 0;
            foreach (var source in sources)
            {
                if (source == null || source.Length <= 0)
                {
                    continue;
                }

                Array.Copy(source, 0, merged, length, source.Length);
                length += source.Length;
            }

            return merged;
        }

        /// <summary>
        /// Get a specified number of random values from a specified array.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="number">The specified number.</param>
        /// <returns>An array of the random value.</returns>
        public static T[] Rand<T>(T[] sources, int number = 1)
        {
            if (sources == null || sources.Length <= 0)
            {
                return new T[number];
            }

            return Slice(Shuffle(sources), 0, Math.Max(number, 1));
        }

        /// <summary>
        /// Shuffle the elements in the specified array.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="seed">The random seed.</param>
        /// <returns>Return the disrupted array.</returns>
        public static T[] Shuffle<T>(T[] sources, int? seed = null)
        {
            if (sources == null || sources.Length <= 0)
            {
                return Array.Empty<T>();
            }

            var requested = new T[sources.Length];
            Array.Copy(sources, requested, sources.Length);

            var random = InternalHelper.MakeRandom(seed);
            for (var i = 0; i < requested.Length; i++)
            {
                var index = random.Next(0, requested.Length - 1);
                if (index == i)
                {
                    continue;
                }

                var temporary = requested[i];
                requested[i] = requested[index];
                requested[index] = temporary;
            }

            return requested;
        }

        /// <summary>
        /// Removes an element of the specified length from the array. If
        /// the <paramref name="replaceSource"/> parameter is given, the new
        /// element is inserted from the <paramref name="start"/> position.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="start">
        /// Delete the start position of the element.
        /// <para>If the value is set to a positive number, delete it from the beginning of the trip.</para>
        /// <para>If the value is set to a negative number, the <paramref name="start"/> absolute value is taken from the back.</para>
        /// </param>
        /// <param name="length">
        /// Number of deleted elements.
        /// <para>If the value is set to a positive number, then the number of elements is returned。.</para>
        /// <para>If the value is set to a negative number, then remove the <paramref name="length"/> absolute position from the back to the front to delete.</para>
        /// <para>If the value is not set, then all elements from the position set by the <paramref name="start"/> parameter to the end of the array are returned.</para>
        /// </param>
        /// <param name="replaceSource">An array inserted at the start position.</param>
        /// <returns>An removed array.</returns>
        public static T[] Splice<T>(ref T[] sources, int start, int? length = null, T[] replaceSource = null)
        {
            if (sources == null || sources.Length <= 0)
            {
                return Array.Empty<T>();
            }

            InternalHelper.NormalizationPosition(sources.Length, ref start, ref length);

            var candidates = new T[length.Value];
            if (length.Value == sources.Length)
            {
                Array.Copy(sources, candidates, sources.Length);
                sources = replaceSource ?? Array.Empty<T>();
                return candidates;
            }

            Array.Copy(sources, start, candidates, 0, length.Value);

            if (replaceSource == null || replaceSource.Length == 0)
            {
                var newSource = new T[sources.Length - length.Value];
                if (start > 0)
                {
                    Array.Copy(sources, 0, newSource, 0, start);
                }

                Array.Copy(sources, start + length.Value, newSource, start, sources.Length - (start + length.Value));
                sources = newSource;
            }
            else
            {
                var newSource = new T[sources.Length - length.Value + replaceSource.Length];
                if (start > 0)
                {
                    Array.Copy(sources, 0, newSource, 0, start);
                }

                Array.Copy(replaceSource, 0, newSource, start, replaceSource.Length);
                Array.Copy(sources, start + length.Value, newSource, start + replaceSource.Length,
                    sources.Length - (start + length.Value));
                sources = newSource;
            }

            return candidates;
        }

        /// <summary>
        /// Crop the array to the desired position.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="source">The source array.</param>
        /// <param name="position">Crop range, negative numbers are trimmed from back to front.</param>
        public static void Cut<T>(ref T[] source, int position)
        {
            if (source == null || source.Length <= 0 || position == 0)
            {
                return;
            }

            if (Math.Abs(position) >= source.Length)
            {
                if (source.Length > 0)
                {
                    Array.Resize(ref source, 0);
                }

                return;
            }

            if (position > 0)
            {
                var size = source.Length - position;
                Array.Copy(source, position, source, 0, size);
                Array.Resize(ref source, size);
            }
            else
            {
                Array.Resize(ref source, source.Length - Math.Abs(position));
            }
        }

        /// <summary>
        /// Divide an array into new array blocks.
        /// <para>The number of cells in each array is determined by
        /// the <paramref name="size"/> parameter. The number of cells in the last array may be a few.</para>
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="size">The size of the block.</param>
        /// <returns>Return an array of the block.</returns>
        public static T[][] Chunk<T>(T[] sources, int size)
        {
            if (sources == null || sources.Length <= 0)
            {
                return Array.Empty<T[]>();
            }

            size = Math.Max(1, size);
            var requested = new T[(sources.Length / size) + (sources.Length % size == 0 ? 0 : 1)][];

            T[] chunks = null;
            for (var i = 0; i < sources.Length; i++)
            {
                var position = i / size;
                if (i % size == 0)
                {
                    if (chunks != null)
                    {
                        requested[position - 1] = chunks;
                    }

                    chunks = new T[(i + size) <= sources.Length ? size : sources.Length - i];
                }

                if (chunks == null)
                {
                    throw new AssertException("Unexpected exception");
                }

                chunks[i - (position * size)] = sources[i];
            }

            requested[requested.Length - 1] = chunks;
            return requested;
        }

        /// <summary>
        /// Fill the array, if the specified array is passed in, it will be filled based on the specified array.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="start">The starting index.</param>
        /// <param name="length">The filling length.</param>
        /// <param name="value">The filling value.</param>
        /// <param name="sources">The specified array.</param>
        /// <returns>Returns an filled array.</returns>
        public static T[] Fill<T>(int start, int length, T value, T[] sources = null)
        {
            Guard.Requires<ArgumentOutOfRangeException>(start >= 0);
            Guard.Requires<ArgumentOutOfRangeException>(length > 0);

            var count = start + length;
            var requested = new T[Math.Max(sources?.Length + length ?? count, count)];

            if (start > 0 && sources != null)
            {
                Array.Copy(sources, requested, Math.Min(sources.Length, start));
            }

            for (var i = start; i < count; i++)
            {
                requested[i] = value;
            }

            if (sources != null && start < sources.Length)
            {
                Array.Copy(sources, start, requested, count, sources.Length - start);
            }

            return requested;
        }

        /// <summary>
        /// Pass each value of the array to the callback function, if the callback
        /// function returns true, remove the corresponding element in the array
        /// and return the removed element.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="predicate">The callback.</param>
        /// <param name="expected">The predicate expected to removed.</param>
        /// <returns>Returns an removed array.</returns>
        public static T[] Remove<T>(ref T[] sources, Predicate<T> predicate, bool expected = true)
        {
            Guard.Requires<ArgumentNullException>(predicate != null, $"Must set a {predicate}.");

            if (sources == null || sources.Length <= 0)
            {
                return Array.Empty<T>();
            }

            var candidateIndex = 0;
            var candidates = new T[sources.Length];
            for (var i = sources.Length - 1; i >= 0; i--)
            {
                if (predicate.Invoke(sources[i]) != expected)
                {
                    continue;
                }

                candidates[candidateIndex++] = sources[i];
                RemoveAt(ref sources, i);
            }

            Array.Reverse(candidates, 0, candidateIndex);
            Array.Resize(ref candidates, candidateIndex);
            return candidates;
        }

        /// <summary>
        /// Each value in the source array is passed to the callback function.
        /// If the callback function is equal to the <paramref name="expected"/>
        /// value, the current value in the input array is added to the result array.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="predicate">The callback.</param>
        /// <param name="expected">The expected value.</param>
        /// <returns>Returns an filtered array.</returns>
        public static T[] Filter<T>(IEnumerable<T> sources, Predicate<T> predicate, bool expected = true)
        {
            Guard.Requires<ArgumentNullException>(predicate != null, $"Must set a {predicate}.");

            if (sources == null)
            {
                return Array.Empty<T>();
            }

            var candidates = new LinkedList<T>();
            foreach (var result in sources)
            {
                if (predicate.Invoke(result) == expected)
                {
                    candidates.AddLast(result);
                }
            }

            return candidates.ToArray();
        }

        /// <summary>
        /// Pass the value of the iterator into the callback function, and the
        /// value returned by the custom function as the new array value.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <typeparam name="TReturn">The type of return value.</typeparam>
        /// <param name="source">The source iterator.</param>
        /// <param name="closure">The closure to process.</param>
        /// <returns>Returns an new array.</returns>
        public static TReturn[] Map<T, TReturn>(IEnumerable<T> source, Func<T, TReturn> closure)
        {
            Guard.Requires<ArgumentNullException>(closure != null, $"Must set a {closure}.");

            if (source == null)
            {
                return Array.Empty<TReturn>();
            }

            var requested = new List<TReturn>();
            foreach (var value in source)
            {
                requested.Add(closure.Invoke(value));
            }

            return requested.ToArray();
        }

        /// <summary>
        /// Delete the last element in the array and return the deleted element
        /// as the return value.
        /// </summary>
        /// <typeparam name="T">The type of the array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <returns>Returns removed element.</returns>
        public static T Pop<T>(ref T[] sources)
        {
            Guard.Requires<ArgumentNullException>(sources != null, $"{nameof(sources)} should not be null.");
            Guard.Requires<InvalidOperationException>(sources.Length > 0, $"The number of elements needs to be greater than 0.");

            var candidate = sources[sources.Length - 1];
            Array.Resize(ref sources, sources.Length - 1);
            return candidate;
        }

        /// <summary>
        /// Add one or more elements to the end of the array.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="elements">The added elements.</param>
        /// <returns>Returns the length of the new array.</returns>
        public static int Push<T>(ref T[] sources, params T[] elements)
        {
            sources = sources ?? Array.Empty<T>();
            if (elements == null || elements.Length <= 0)
            {
                return sources.Length;
            }

            Array.Resize(ref sources, sources.Length + elements.Length);
            Array.Copy(elements, 0, sources, sources.Length - elements.Length, elements.Length);
            return sources.Length;
        }

        /// <summary>
        /// Pass a value from an array to a callback function and return a string.
        /// <para>The function returns null if the array is empty and the <paramref name="initial"/> parameter is not passed.</para>
        /// <para>If the <paramref name="initial"/> parameter is specified, the parameter will be treated as the first value
        /// in the array, and if the array is empty, it will be the final return value (string).</para>
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="closure">The closure process.</param>
        /// <param name="initial">The initial value.</param>
        /// <returns>Returnd the processed string.</returns>
        public static string Reduce<T>(IEnumerable<T> sources, Func<object, T, string> closure, object initial = null)
        {
            Guard.Requires<ArgumentNullException>(closure != null, $"Must set a {closure}.");

            if (sources == null)
            {
                return initial?.ToString();
            }

            var requested = initial;
            foreach (var segments in sources)
            {
                requested = closure.Invoke(requested, segments);
            }

            return requested?.ToString();
        }

        /// <summary>
        /// Take a value from the array according to the condition and return.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="start">
        /// Remove the starting position of the element.
        /// <para>If the value is set to a positive number, it will be taken from the beginning of the trip.</para>
        /// <para>If the value is set to a negative number, the <paramref name="start"/> absolute value is taken from the back.</para>
        /// </param>
        /// <param name="length">
        /// Returns the length of the array.
        /// <para>If the value is set to a positive number, then the number of elements is returned。.</para>
        /// <para>If the value is set to a negative number, then remove the <paramref name="length"/> absolute position from the back to the front to delete.</para>
        /// <para>If the value is not set, then all elements from the position set by the <paramref name="start"/> parameter to the end of the array are returned.</para>
        /// </param>
        /// <returns>Returns an new array.</returns>
        public static T[] Slice<T>(T[] sources, int start, int? length = null)
        {
            if (sources == null || sources.Length <= 0)
            {
                return Array.Empty<T>();
            }

            InternalHelper.NormalizationPosition(sources.Length, ref start, ref length);

            var requested = new T[length.Value];
            Array.Copy(sources, start, requested, 0, length.Value);
            return requested;
        }

        /// <summary>
        /// Removed the first element in the array and return the value of the removed element.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <returns>Returns the removed value.</returns>
        public static T Shift<T>(ref T[] sources)
        {
            Guard.Requires<ArgumentNullException>(sources != null, $"{nameof(sources)} should not be null.");
            Guard.Requires<InvalidOperationException>(sources.Length > 0, $"The number of elements needs to be greater than 0.");

            var candidate = sources[0];
            var newSource = new T[sources.Length - 1];

            Array.Copy(sources, 1, newSource, 0, sources.Length - 1);
            sources = newSource;
            return candidate;
        }

        /// <summary>
        /// Add a new element at the beginning of the array.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="elements">The added element.</param>
        /// <returns>Returns the length of the new array.</returns>
        public static int Unshift<T>(ref T[] sources, params T[] elements)
        {
            sources = sources ?? Array.Empty<T>();
            if (elements == null || elements.Length <= 0)
            {
                return sources.Length;
            }

            var newSources = new T[sources.Length + elements.Length];

            Array.Copy(elements, newSources, elements.Length);
            Array.Copy(sources, 0, newSources, elements.Length, sources.Length);

            sources = newSources;

            return sources.Length;
        }

        /// <summary>
        /// Return arrays in reverse order.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="start">
        /// The starting position of the starting element.
        /// <para>If the value is set to a positive number, it will be taken from the beginning of the trip.</para>
        /// <para>If the value is set to a negative number, the <paramref name="start"/> absolute value is taken from the back.</para></param>
        /// <param name="length">
        /// Returns the length of the array.
        /// <para>If the value is set to a positive number, then the number of elements is returned。.</para>
        /// <para>If the value is set to a negative number, then remove the <paramref name="length"/> absolute position from the back to the front to delete.</para>
        /// <para>If the value is not set, then all elements from the position set by the <paramref name="start"/> parameter to the end of the array are returned.</para>
        /// </param>
        /// <returns>Returns inverted array.</returns>
        public static T[] Reverse<T>(T[] sources, int start = 0, int? length = null)
        {
            if (sources == null || sources.Length <= 0)
            {
                return Array.Empty<T>();
            }

            if (sources.Length == 1)
            {
                return sources;
            }

            InternalHelper.NormalizationPosition(sources.Length, ref start, ref length);
            var temporarySource = new T[sources.Length];
            Array.Copy(sources, temporarySource, sources.Length);
            Array.Reverse(temporarySource, start, length.Value);

            var resquested = new T[length.Value];
            Array.Copy(temporarySource, start, resquested, 0, length.Value);
            return resquested;
        }

        /// <summary>
        /// Retrieve the initial element index that matches all matching values from the array.
        /// If it returns -1, it means that it does not appear.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="source">The specified array.</param>
        /// <param name="match">The value to match, if there are more than one, only all matches will match.</param>
        /// <returns>Returning -1 means that the specified value was not retrieved.</returns>
        public static int IndexOf<T>(T[] source, params T[] match)
        {
            if (match == null || match.Length <= 0
                || source == null || source.Length <= 0)
            {
                return -1;
            }

            for (var sourceIndex = 0; sourceIndex < source.Length; sourceIndex++)
            {
                if (!source[sourceIndex].Equals(match[0]))
                {
                    continue;
                }

                var isFinded = true;

                for (var matchIndex = 0; matchIndex < match.Length; matchIndex++)
                {
                    if ((sourceIndex + matchIndex) < source.Length &&
                          source[sourceIndex + matchIndex].Equals(match[matchIndex]))
                    {
                        continue;
                    }

                    isFinded = false;
                    break;
                }

                if (isFinded)
                {
                    return sourceIndex;
                }
            }

            return -1;
        }

        /// <summary>
        /// Retrieve the subscript of the specified arbitrary matching value from the array.
        /// If it returns -1, it means that it does not appear.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="source">The specified array.</param>
        /// <param name="match">The value to match.Match as long as there is an element match.</param>
        /// <returns>Returning -1 means that the specified value was not retrieved.</returns>
        public static int IndexOfAny<T>(T[] source, params T[] match)
        {
            if (match == null || match.Length <= 0
                || source == null || source.Length <= 0)
            {
                return -1;
            }

            for (var sourceIndex = 0; sourceIndex < source.Length; sourceIndex++)
            {
                for (var matchIndex = 0; matchIndex < match.Length; matchIndex++)
                {
                    if (source[sourceIndex].Equals(match[matchIndex]))
                    {
                        return sourceIndex;
                    }
                }
            }

            return -1;
        }

        /// <summary>
        /// Exclude the specified value in the array.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The source array.</param>
        /// <param name="matches">An array of exclude value.</param>
        /// <returns>Returns an array of processed.</returns>
        public static T[] Difference<T>(T[] sources, params T[] matches)
        {
            if (sources == null || sources.Length <= 0 || matches == null || matches.Length <= 0)
            {
                return sources;
            }

            return Filter(sources, (source) =>
            {
                foreach (var match in matches)
                {
                    if (source.Equals(match))
                    {
                        return false;
                    }
                }

                return true;
            });
        }

        /// <summary>
        /// Remove and return the array element of the specified index.
        /// <para>If the index is passed a negative number then it will be removed from the end.</para>
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="index">The index of array.</param>
        /// <param name="defaultValue">Default value if index not found.</param>
        /// <returns>Returns removed element.</returns>
        public static T RemoveAt<T>(ref T[] sources, int index, T defaultValue = default)
        {
            if (sources == null || sources.Length <= 0 || index >= sources.Length)
            {
                return defaultValue;
            }

            var candidates = Splice(ref sources, index, 1);
            return candidates.Length > 0 ? candidates[0] : defaultValue;
        }

        /// <summary>
        /// Pass the specified array to the callback test.
        /// <para>The function returns false only if all elements pass the checker are false.</para>
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="predicate">The callback.</param>
        /// <returns>True if pass the test.</returns>
        public static bool Test<T>(IEnumerable<T> sources, Predicate<T> predicate)
        {
            return Test(sources, predicate, out _);
        }

        /// <summary>
        /// Pass the specified array to the callback test.
        /// <para>The function returns false only if all elements pass the checker are false.</para>
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="predicate">The callback.</param>
        /// <param name="match">Test passed element.</param>
        /// <returns>True if pass the test.</returns>
        public static bool Test<T>(IEnumerable<T> sources, Predicate<T> predicate, out T match)
        {
            Guard.Requires<ArgumentNullException>(predicate != null, $"Must set a {predicate}.");

            match = default;
            if (sources == null)
            {
                return false;
            }

            foreach (var source in sources)
            {
                if (predicate(source))
                {
                    match = source;
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Finds the specified element in the specified array, and replaces it with a substitute value if found,
        /// otherwise adds a replacement value at the end of the specified array.
        /// </summary>
        /// <typeparam name="T">The type of array.</typeparam>
        /// <param name="sources">The specified array.</param>
        /// <param name="predicate">The callback to find element.</param>
        /// <param name="value">The replacement value.</param>
        public static void Set<T>(ref T[] sources, Predicate<T> predicate, T value)
        {
            Guard.Requires<ArgumentNullException>(predicate != null, $"Must set a {predicate}.");

            sources = sources ?? Array.Empty<T>();

            for (var index = 0; index < sources.Length; index++)
            {
                if (!predicate(sources[index]))
                {
                    continue;
                }

                sources[index] = value;
                return;
            }

            Push(ref sources, value);
        }
    }
}


================================================
FILE: src/CatLib.Core/Util/Guard.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;
using System.Collections.Generic;
using System.Reflection;
using SException = System.Exception;

namespace CatLib.Util
{
    /// <summary>
    /// Guard the code.
    /// </summary>
    public sealed class Guard
    {
        private static Guard that;
        private static IDictionary<Type, ExtendException> exceptionFactory;

        /// <summary>
        /// Indicates an extended exception factory.
        /// </summary>
        /// <param name="message">The exception message.</param>
        /// <param name="innerException">The inner exception instance.</param>
        /// <param name="state">The user object.</param>
        /// <returns>An exception instance.</returns>
        public delegate SException ExtendException(string message, SException innerException, object state);

        /// <summary>
        /// Gets the singleton instance of the Guard functionality.
        /// </summary>
        /// <remarks>Users can use this to plug-in custom assertions through csharp extension methods.</remarks>
        public static Guard That
        {
            get
            {
                if (that == null)
                {
                    that = new Guard();
                }

                return that;
            }
        }

        /// <summary>
        /// Verifies a condition and throws an exception if the condition of the contract fails.
        /// </summary>
        /// <typeparam name="TException">Exception triggered when validation fails.</typeparam>
        /// <param name="condition">The condition of the contract.</param>
        /// <param name="message">The error message that explains the reason for the exception.</param>
        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference.</param>
        /// <param name="state">State will be passed to the registered exception build factory.</param>
        [System.Diagnostics.DebuggerNonUserCode]
        public static void Requires<TException>(bool condition, string message = null, SException innerException = null, object state = null)
            where TException : SException, new()
        {
            Requires(typeof(TException), condition, message, innerException, state);
        }

        /// <summary>
        /// Verifies a condition and throws an exception if the condition of the contract fails.
        /// </summary>
        /// <param name="exception">Exception triggered when validation fails.</param>
        /// <param name="condition">The condition of the contract.</param>
        /// <param name="message">The error message that explains the reason for the exception.</param>
        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference.</param>
        /// <param name="state">State will be passed to the registered exception build factory.</param>
        [System.Diagnostics.DebuggerNonUserCode]
        public static void Requires(Type exception, bool condition, string message = null, SException innerException = null, object state = null)
        {
            if (condition)
            {
                return;
            }

            throw CreateExceptionInstance(exception, message, innerException, state);
        }

        /// <summary>
        /// The verification parameter is not Null.
        /// </summary>
        /// <param name="argumentValue">The parameter value.</param>
        /// <param name="argumentName">The parameter name.</param>
        /// <param name="message">The error message that explains the reason for the exception.</param>
        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference.</param>
        [System.Diagnostics.DebuggerNonUserCode]
        public static void ParameterNotNull(object argumentValue, string argumentName, string message = null, SException innerException = null)
        {
            if (argumentValue != null)
            {
                return;
            }

            message = message ?? $"Parameter {argumentName} not allowed for null. please check the function input.";
            var exception = new ArgumentNullException(argumentName, message);

            if (innerException != null)
            {
                SetField(exception, "_innerException", innerException);
            }

            throw exception;
        }

        /// <summary>
        /// Extend an exception generation factory.
        /// </summary>
        /// <typeparam name="T">The type of exception.</typeparam>
        /// <param name="factory">The exception factory.</param>
        [System.Diagnostics.DebuggerNonUserCode]
        public static void Extend<T>(ExtendException factory)
        {
            Extend(typeof(T), factory);
        }

        /// <summary>
        /// Extend an exception generation factory.
        /// </summary>
        /// <param name="exception">The type of exception.</param>
        /// <param name="factory">The exception factory.</param>
        [System.Diagnostics.DebuggerNonUserCode]
        public static void Extend(Type exception, ExtendException factory)
        {
            VerfiyExceptionFactory();
            exceptionFactory[exception] = factory;
        }

        private static SException CreateExceptionInstance(Type exceptionType, string message, SException innerException, object state)
        {
            if (!typeof(SException).IsAssignableFrom(exceptionType))
            {
                throw new ArgumentException(
                    $"Type: {exceptionType} must be inherited from: {typeof(SException)}.",
                    nameof(exceptionType));
            }

            VerfiyExceptionFactory();

            if (exceptionFactory.TryGetValue(exceptionType, out ExtendException factory))
            {
                var ret = factory(message, innerException, state);
                if (ret != null)
                {
                    return ret;
                }
            }

            var exception = Activator.CreateInstance(exceptionType);
            if (!string.IsNullOrEmpty(message))
            {
                SetField(exception, "_message", message);
            }

            if (innerException != null)
            {
                SetField(exception, "_innerException", innerException);
            }

            return (SException)exception;
        }

        private static void VerfiyExceptionFactory()
        {
            if (exceptionFactory == null)
            {
                exceptionFactory = new Dictionary<Type, ExtendException>();
            }
        }

        private static void SetField(object obj, string field, object value)
        {
            var flag = BindingFlags.Instance | BindingFlags.NonPublic;
            var fieldInfo = obj.GetType().GetField(field, flag);

            if (fieldInfo != null)
            {
                fieldInfo.SetValue(obj, value);
            }
        }
    }
}


================================================
FILE: src/CatLib.Core/Util/InternalHelper.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;

namespace CatLib.Util
{
    /// <summary>
    /// Represents an internal generic helper class.
    /// </summary>
    internal static class InternalHelper
    {
        internal static Random MakeRandom(int? seed = null)
        {
            return new Random(seed.GetValueOrDefault(MakeSeed()));
        }

        internal static int MakeSeed()
        {
            return Environment.TickCount ^ Guid.NewGuid().GetHashCode();
        }

        internal static void NormalizationPosition(int sourceLength, ref int start, ref int? length)
        {
            start = (start >= 0) ? Math.Min(start, sourceLength) : Math.Max(sourceLength + start, 0);

            if (length == null)
            {
                length = Math.Max(sourceLength - start, 0);
                return;
            }

            length = (length >= 0)
                    ? Math.Min(length.Value, sourceLength - start)
                    : Math.Max(sourceLength + length.Value - start, 0);
        }
    }
}


================================================
FILE: src/CatLib.Core/Util/SortSet.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

#pragma warning disable S2589
#pragma warning disable S2583
#pragma warning disable S2259

namespace CatLib.Util
{
    /// <summary>
    /// Represents an ordered set, implemented by a jump list.
    /// </summary>
    /// <typeparam name="TElement">The element type.</typeparam>
    /// <typeparam name="TScore">The score type.</typeparam>
    [DebuggerDisplay("Count = {" + nameof(Count) + "}")]
#pragma warning disable CA1710
    public sealed class SortSet<TElement, TScore> : IEnumerable<TElement>
        where TScore : IComparable<TScore>
#pragma warning restore CA1710
    {
        private readonly int maxLevel;
        private readonly SkipNode header;
        private readonly double probability;
        private readonly Random random = new Random();
        private readonly IComparer<TScore> comparer;
        private readonly Dictionary<TElement, TScore> elementMapping = new Dictionary<TElement, TScore>();
        private int level;
        private SkipNode tail;

        /// <summary>
        /// Initializes a new instance of the <see cref="SortSet{TElement, TScore}"/> class.
        /// </summary>
        /// <param name="probable">Probability coefficient of possible number of level(0-1).</param>
        /// <param name="maxLevel">The max level.</param>
        public SortSet(double probable = 0.25, int maxLevel = 32)
        {
            Guard.Requires<ArgumentOutOfRangeException>(probable < 1);
            Guard.Requires<ArgumentOutOfRangeException>(probable > 0);

            maxLevel = Math.Max(1, maxLevel);

            probability = probable * 0xFFFF;
            level = 1;
            this.maxLevel = maxLevel;
            header = new SkipNode
            {
                Level = new SkipNode.SkipNodeLevel[maxLevel],
            };
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SortSet{TElement, TScore}"/> class.
        /// </summary>
        /// <param name="comparer">The comparer.</param>
        /// <param name="probable">Probability coefficient of possible number of level(0-1).</param>
        /// <param name="maxLevel">The max level.</param>
        public SortSet(IComparer<TScore> comparer, double probable = 0.25, int maxLevel = 32)
            : this(probable, maxLevel)
        {
            Guard.Requires<ArgumentNullException>(comparer != null);
            this.comparer = comparer;
        }

        /// <summary>
        /// Gets the element count.
        /// </summary>
        public int Count { get; private set; }

        /// <summary>
        /// Get the element of the specified ranking.
        /// </summary>
        /// <param name="rank">The ranking(0 is the bottom).</param>
        /// <returns>The element.</returns>
        public TElement this[int rank] => GetElementByRank(rank);

        /// <summary>
        /// Clear the <see cref="SortSet{TElement, TScore}"/>.
        /// </summary>
        public void Clear()
        {
            for (var i = 0; i < header.Level.Length; ++i)
            {
                header.Level[i].Span = 0;
                header.Level[i].Forward = null;
            }

            tail = null;
            level = 1;
            Count = 0;
            elementMapping.Clear();
        }

        /// <summary>
        /// Get <see cref="SortSet{TElement, TScore}"/> iterator.
        /// </summary>
        /// <param name="forward">True if iterator element forward.</param>
        /// <returns>Returns iterator instance.</returns>
        public IEnumerable<TElement> GetIterator(bool forward = true)
        {
            return new Iterator(this, forward);
        }

        /// <inheritdoc />
        IEnumerator<TElement> IEnumerable<TElement>.GetEnumerator()
        {
            return new Iterator(this, true);
        }

        /// <inheritdoc />
        IEnumerator IEnumerable.GetEnumerator()
        {
            return new Iterator(this, true);
        }

        /// <summary>
        /// Convert to array.
        /// </summary>
        /// <returns>An element array.</returns>
        public TElement[] ToArray()
        {
            var elements = new TElement[Count];
            var node = header.Level[0];
            var i = 0;
            while (node.Forward != null)
            {
                elements[i++] = node.Forward.Element;
                node = node.Forward.Level[0];
            }

            return elements;
        }

        /// <summary>
        /// Gets the first element.
        /// </summary>
        /// <returns>The first element.</returns>
        public TElement First()
        {
            if (header.Level[0].Forward != null)
            {
                return header.Level[0].Forward.Element;
            }

            throw new InvalidOperationException($"{nameof(SortSet<TElement, TScore>)} is empty.");
        }

        /// <summary>
        /// Gets the last element.
        /// </summary>
        /// <returns>The last element.</returns>
        public TElement Last()
        {
            if (tail != null)
            {
                return tail.Element;
            }

            throw new InvalidOperationException($"{nameof(SortSet<TElement, TScore>)} is empty");
        }

        /// <summary>
        /// Remove and return the elements at the head.
        /// </summary>
        /// <returns>The first element.</returns>
        public TElement Shift()
        {
            if (!Remove(header.Level[0].Forward, out TElement ret))
            {
                throw new InvalidOperationException($"{nameof(SortSet<TElement, TScore>)} is empty");
            }

            return ret;
        }

        /// <summary>
        /// Remove and return the elements at the end.
        /// </summary>
        /// <returns>The last element.</returns>
        public TElement Pop()
        {
            if (!Remove(tail, out TElement ret))
            {
                throw new InvalidOperationException($"{nameof(SortSet<TElement, TScore>)} is empty");
            }

            return ret;
        }

        /// <summary>
        /// Add a new record in sortset.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="score">The score.</param>
        public void Add(TElement element, TScore score)
        {
            Guard.Requires<ArgumentNullException>(
                element != null,
                $"{nameof(element)} should not be null.");
            Guard.Requires<ArgumentNullException>(
                score != null,
                $"{nameof(score)} should not be null.");

            if (elementMapping.TryGetValue(element, out TScore dictScore))
            {
                Remove(element, dictScore);
            }

            AddElement(element, score);
        }

        /// <summary>
        /// Whether is contains the specided element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns>True if contains the specided element.</returns>
        public bool Contains(TElement element)
        {
            Guard.Requires<ArgumentNullException>(
                element != null,
                $"{nameof(element)} should not be null.");
            return elementMapping.ContainsKey(element);
        }

        /// <summary>
        /// Gets the element's score.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns>The element's score.</returns>
        public TScore GetScore(TElement element)
        {
            Guard.Requires<ArgumentNullException>(
                element != null,
                $"{nameof(element)} should not be null.");

            if (!elementMapping.TryGetValue(element, out TScore score))
            {
                throw new KeyNotFoundException();
            }

            return score;
        }

        /// <summary>
        /// Get the number of elements in the specified score range.
        /// </summary>
        /// <param name="start">The start score.(contain).</param>
        /// <param name="end">The end score.(contain).</param>
        /// <returns>The number of elements in the score range.</returns>
        public int GetRangeCount(TScore start, TScore end)
        {
            Guard.Requires<ArgumentNullException>(
                start != null,
                $"{nameof(start)} should not be null.");
            Guard.Requires<ArgumentNullException>(
                end != null,
                $"{nameof(end)} should not be null.");
            Guard.Requires<ArgumentOutOfRangeException>(
                Compare(start, end) <= 0,
                $"{nameof(start)} should not larger than {nameof(end)}.");

            int rank = 0, leftRank = 0;
            SkipNode leftCursor = null;

            var isRight = false;
            var cursor = header;

            do
            {
                for (var i = level - 1; i >= 0; --i)
                {
                    while (cursor.Level[i].Forward != null &&
                           ((!isRight && Compare(cursor.Level[i].Forward.Score, start) < 0) ||
                            (isRight && Compare(cursor.Level[i].Forward.Score, end) <= 0)))
                    {
                        rank += cursor.Level[i].Span;
                        cursor = cursor.Level[i].Forward;
                    }

                    if (leftCursor != null)
                    {
                        continue;
                    }

                    // First set the skip cursor and ranking of the top leftmost level.
                    // Than the cursor will start to look down.
                    leftCursor = cursor;
                    leftRank = rank;
                }

                if (isRight)
                {
                    continue;
                }

                cursor = leftCursor;

                var foo = rank;
                rank = leftRank;
                leftRank = foo;
            }
#pragma warning disable S1121
            while (isRight = !isRight);
#pragma warning restore S1121

            return Math.Max(0, rank - leftRank);
        }

        /// <summary>
        /// Remove an element from the sortset, return false if the element does not exist.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns>Whether is removed the element.</returns>
        public bool Remove(TElement element)
        {
            Guard.Requires<ArgumentNullException>(
                element != null,
                $"{nameof(element)} should not be null.");

            return elementMapping.TryGetValue(element, out TScore score) && Remove(element, score);
        }

        /// <summary>
        /// Remove elements from the rank range.
        /// </summary>
        /// <param name="startRank">The start rank.(contains, 0 bottom).</param>
        /// <param name="stopRank">The end rank.(contains, 0 bottom).</param>
        /// <returns>Returns the removed elements count.</returns>
        public int RemoveRangeByRank(int startRank, int stopRank)
        {
            startRank = Math.Max(startRank, 0);
            Guard.Requires<ArgumentOutOfRangeException>(
                startRank <= stopRank,
                $"{nameof(startRank)} should not larger than {nameof(stopRank)}.");

            int traversed = 0, removed = 0;
            var update = new SkipNode[maxLevel];
            var cursor = header;
            for (var i = level - 1; i >= 0; --i)
            {
                while (cursor.Level[i].Forward != null &&
                       (traversed + cursor.Level[i].Span <= startRank))
                {
                    traversed += cursor.Level[i].Span;
                    cursor = cursor.Level[i].Forward;
                }

                update[i] = cursor;
            }

            cursor = cursor.Level[0].Forward;

            while (cursor != null &&
                    traversed <= stopRank)
            {
                var next = cursor.Level[0].Forward;
                elementMapping.Remove(cursor.Element);
                DeleteNode(cursor, update);
                ++removed;
                ++traversed;
                cursor = next;
            }

            return removed;
        }

        /// <summary>
        /// Remove elements from the score range.
        /// </summary>
        /// <param name="startScore">The start score.（contains）.</param>
        /// <param name="stopScore">The end score.（contains）.</param>
        /// <returns>Returns removed elements count.</returns>
        public int RemoveRangeByScore(TScore startScore, TScore stopScore)
        {
            Guard.Requires<ArgumentNullException>(
                startScore != null,
                $"{nameof(startScore)} should not be null.");
            Guard.Requires<ArgumentNullException>(
                stopScore != null,
                $"{nameof(stopScore)} should not be null.");
            Guard.Requires<ArgumentOutOfRangeException>(
                Compare(startScore, stopScore) <= 0,
                $"{nameof(startScore)} should not larger than {nameof(stopScore)}.");

            var removed = 0;
            var update = new SkipNode[maxLevel];
            var cursor = header;
            for (var i = level - 1; i >= 0; --i)
            {
                while (cursor.Level[i].Forward != null &&
                       Compare(cursor.Level[i].Forward.Score, startScore) < 0)
                {
                    cursor = cursor.Level[i].Forward;
                }

                update[i] = cursor;
            }

            cursor = cursor.Level[0].Forward;

            while (cursor != null &&
                   Compare(cursor.Score, stopScore) <= 0)
            {
                var next = cursor.Level[0].Forward;
                elementMapping.Remove(cursor.Element);
                DeleteNode(cursor, update);
                ++removed;
                cursor = next;
            }

            return removed;
        }

        /// <summary>
        /// Get specific element rank.
        /// </summary>
        /// <param name="element">The specific element.</param>
        /// <returns>Returns the element rank(0 bottom) -1 means not found element.</returns>
        public int GetRank(TElement element)
        {
            Guard.Requires<ArgumentNullException>(
                element != null,
                $"{nameof(element)} should not be null.");
            return elementMapping.TryGetValue(element, out TScore dictScore) ? GetRank(element, dictScore) : -1;
        }

        /// <summary>
        /// Get the reverse ranking of the specified element.
        /// </summary>
        /// <param name="element">The specified element.</param>
        /// <returns>The element's rank(0 bottom)-1 means not found element.</returns>
        public int GetRevRank(TElement element)
        {
            Guard.Requires<ArgumentNullException>(
                element != null,
                $"{nameof(element)} should not be null.");
            var rank = GetRank(element);
            return rank < 0 ? rank : Count - rank - 1;
        }

        /// <summary>
        /// Get the elements in the ranking range.
        /// </summary>
        /// <param name="startRank">The start rank(contains).</param>
        /// <param name="stopRank">The stop rank(contains).</param>
        /// <returns>An array of the elements.</returns>
        public TElement[] GetElementRangeByRank(int startRank, int stopRank)
        {
            startRank = Math.Max(startRank, 0);
            Guard.Requires<ArgumentOutOfRangeException>(
                startRank <= stopRank,
                $"{nameof(startRank)} should not larger than {nameof(stopRank)}.");

            int traversed = 0;
            var cursor = header;
            for (var i = level - 1; i >= 0; --i)
            {
                while (cursor.Level[i].Forward != null &&
                       (traversed + cursor.Level[i].Span <= startRank))
                {
                    traversed += cursor.Level[i].Span;
                    cursor = cursor.Level[i].Forward;
                }
            }

            cursor = cursor.Level[0].Forward;

            var result = new List<TElement>();
            while (cursor != null &&
                   traversed <= stopRank)
            {
                result.Add(cursor.Element);
                ++traversed;
                cursor = cursor.Level[0].Forward;
            }

            return result.ToArray();
        }

        /// <summary>
        /// Get the elements in the score range.
        /// </summary>
        /// <param name="startScore">The start score（contains）.</param>
        /// <param name="stopScore">The end score（contains）.</param>
        /// <returns>An array of the elements.</returns>
        public TElement[] GetElementRangeByScore(TScore startScore, TScore stopScore)
        {
            Guard.Requires<ArgumentNullException>(
                startScore != null,
                $"{nameof(startScore)} should not be null.");
            Guard.Requires<ArgumentNullException>(
                stopScore != null,
                $"{nameof(stopScore)} should not be null.");
            Guard.Requires<ArgumentOutOfRangeException>(
                Compare(startScore, stopScore) <= 0,
                $"{nameof(startScore)} should not larger than {nameof(stopScore)}.");

            var cursor = header;
            for (var i = level - 1; i >= 0; --i)
            {
                while (cursor.Level[i].Forward != null &&
                       Compare(cursor.Level[i].Forward.Score, startScore) < 0)
                {
                    cursor = cursor.Level[i].Forward;
                }
            }

            cursor = cursor.Level[0].Forward;

            var result = new List<TElement>();
            while (cursor != null &&
                   Compare(cursor.Score, stopScore) <= 0)
            {
                result.Add(cursor.Element);
                cursor = cursor.Level[0].Forward;
            }

            return result.ToArray();
        }

        /// <summary>
        /// Get element by rank.
        /// </summary>
        /// <param name="rank">The rank(0 bottom).</param>
        /// <returns>The element.</returns>
        public TElement GetElementByRank(int rank)
        {
            rank = Math.Max(0, rank);
            rank += 1;
            var traversed = 0;
            var cursor = header;
            for (var i = level - 1; i >= 0; i--)
            {
                while (cursor.Level[i].Forward != null &&
                       (traversed + cursor.Level[i].Span) <= rank)
                {
                    traversed += cursor.Level[i].Span;
                    cursor = cursor.Level[i].Forward;
                }

                if (traversed == rank)
                {
                    return cursor.Element;
                }
            }

            if (Count > 0)
            {
                throw new ArgumentOutOfRangeException($"Rank is out of range [{rank}]");
            }

            throw new InvalidOperationException("SortSet is Null");
        }

        /// <summary>
        /// Get element by reverse rank.
        /// </summary>
        /// <param name="rank">The rank.(0 bottom).</param>
        /// <returns>The element.</returns>
        public TElement GetElementByRevRank(int rank)
        {
            return GetElementByRank(Count - rank - 1);
        }

        /// <summary>
        /// Add an element in the sortset.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="score">The score.</param>
        private void AddElement(TElement element, TScore score)
        {
            int i;
            elementMapping.Add(element, score);

            var update = new SkipNode[maxLevel];
            var cursor = header;
            var rank = new int[maxLevel];

            // Find from high to low skip level
            for (i = level - 1; i >= 0; --i)
            {
                // Rank is the starting point of the node of the previous level as the starting point.
                rank[i] = i == (level - 1) ? 0 : rank[i + 1];
                while (cursor.Level[i].Forward != null &&
                        (Compare(cursor.Level[i].Forward.Score, score) < 0))
                {
                    rank[i] += cursor.Level[i].Span;
                    cursor = cursor.Level[i].Forward;
                }

                // Place the last node found in the node that needs to be updated
                update[i] = cursor;
            }

            var newLevel = GetRandomLevel();

            if (newLevel > level)
            {
                for (i = level; i < newLevel; ++i)
                {
                    rank[i] = 0;
                    update[i] = header;
                    update[i].Level[i].Span = Count;
                }

                level = newLevel;
            }

            // Point the cursor to a new skip node
            cursor = new SkipNode
            {
                Element = element,
                Score = score,
                Level = new SkipNode.SkipNodeLevel[newLevel],
            };

            for (i = 0; i < newLevel; ++i)
            {
                cursor.Level[i].Forward = update[i].Level[i].Forward;
                update[i].Level[i].Forward = cursor;
                cursor.Level[i].Span = update[i].Level[i].Span - (rank[0] - rank[i]);
                update[i].Level[i].Span = (rank[0] - rank[i]) + 1;
            }

            for (i = newLevel; i < level; ++i)
            {
                ++update[i].Level[i].Span;
            }

            cursor.Backward = (update[0] == header) ? null : update[0];

            if (cursor.Level[0].Forward != null)
            {
                cursor.Level[0].Forward.Backward = cursor;
            }
            else
            {
                tail = cursor;
            }

            ++Count;
        }

        /// <summary>
        /// Remove the skip node.
        /// </summary>
        /// <param name="node">The skip node.</param>
        /// <param name="element">The removed element.</param>
        /// <returns>Whether is removed the element.</returns>
        private bool Remove(SkipNode node, out TElement element)
        {
            if (node == null)
            {
                element = default;
                return false;
            }

            var result = node.Element;
            if (!Remove(node.Element, node.Score))
            {
                element = default;
                return false;
            }

            element = result;
            return true;
        }

        /// <summary>
        /// Remove the skip node.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="score">The score.</param>
        /// <returns>Whether is removed the element.</returns>
        private bool Remove(TElement element, TScore score)
        {
            Guard.Requires<ArgumentNullException>(
                element != null,
                $"{nameof(element)} should not be null.");
            Guard.Requires<ArgumentNullException>(
                score != null,
                $"{nameof(score)} should not be null.");

            var update = new SkipNode[maxLevel];
            var cursor = header;

            for (var i = level - 1; i >= 0; --i)
            {
                while (IsFindNext(cursor.Level[i].Forward, element, score, i))
                {
                    cursor = cursor.Level[i].Forward;
                }

                update[i] = cursor;
            }

            cursor = update[0].Level[0].Forward;

            if (cursor == null ||
                Compare(cursor.Score, score) != 0 ||
                        !cursor.Element.Equals(element))
            {
                return false;
            }

            elementMapping.Remove(element);
            DeleteNode(cursor, update);
            return true;
        }

        /// <summary>
        /// Get the element rank.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="score">The element score.</param>
        /// <returns>The element rank.</returns>
        private int GetRank(TElement element, TScore score)
        {
            var rank = 0;
            var cursor = header;
            for (var i = level - 1; i >= 0; --i)
            {
                while (IsFindNext(cursor.Level[i].Forward, element, score, i))
                {
                    rank += cursor.Level[i].Span;
                    cursor = cursor.Level[i].Forward;
                }
            }

            cursor = cursor.Level[0].Forward;

            if (cursor != null && cursor != header &&
                cursor.Element != null &&
                cursor.Element.Equals(element))
            {
                return rank;
            }

            return -1;
        }

        /// <summary>
        /// Determine if you need to find the next node.
        /// </summary>
        /// <param name="node">The skip not.</param>
        /// <param name="element">The element.</param>
        /// <param name="score">The element score.</param>
        /// <param name="level">The level.</param>
        /// <returns>True if find next.</returns>
        private bool IsFindNext(SkipNode node, TElement element, TScore score, int level)
        {
            if (node == null)
            {
                return false;
            }

            var compare = Compare(node.Score, score);
            if (compare < 0 || compare > 0)
            {
                return compare < 0;
            }

            // If the level is greater than 0, it means that it is possible
            // to directly locate element 2, resulting in a bug.
            // So we think that the level is greater than 0, then the value
            // is equal and still returns the pre-order jump node.
            //
            // ----------------------------------------------------
            // |  element 1（score：50）  | element 2 （score：50）
            // ----------------------------------------------------
            if (level > 0)
            {
                return false;
            }

            return !node.Element.Equals(element);
        }

        /// <summary>
        /// Delete the skip node.
        /// </summary>
        /// <param name="cursor">The skip node.</param>
        /// <param name="update">The updated node list.</param>
        private void DeleteNode(SkipNode cursor, SkipNode[] update)
        {
            for (var i = 0; i < level; ++i)
            {
                if (update[i].Level[i].Forward == cursor)
                {
                    update[i].Level[i].Span += cursor.Level[i].Span - 1;
                    update[i].Level[i].Forward = cursor.Level[i].Forward;
                }
                else
                {
                    update[i].Level[i].Span -= 1;
                }
            }

            if (cursor.Level[0].Forward != null)
            {
                cursor.Level[0].Forward.Backward = cursor.Backward;
            }
            else
            {
                tail = cursor.Backward;
            }

            while (level > 1 && header.Level[level - 1].Forward == null)
            {
                --level;
            }

            cursor.IsDeleted = true;
            --Count;
        }

        /// <summary>
        /// Get the rand level.
        /// </summary>
        /// <returns>The rand level.</returns>
        private int GetRandomLevel()
        {
            var newLevel = 1;
            while (random.Next(0, 0xFFFF) < probability)
            {
                ++newLevel;
            }

            return (newLevel < maxLevel) ? newLevel : maxLevel;
        }

        /// <summary>
        /// Compare left and right values.
        /// </summary>
        /// <param name="left">The left value.</param>
        /// <param name="right">The right value.</param>
        /// <returns>Return a value indicating which value is larger.</returns>
        private int Compare(TScore left, TScore right)
        {
            return comparer?.Compare(left, right) ?? left.CompareTo(right);
        }

        /// <summary>
        /// The default iterator.
        /// </summary>
#pragma warning disable CA1710
        public struct Iterator : IEnumerator<TElement>, IEnumerable<TElement>
#pragma warning restore CA1710
        {
            /// <summary>
            /// The sorset instance.
            /// </summary>
            private readonly SortSet<TElement, TScore> collection;

            /// <summary>
            /// Whether to traverse from the forward.
            /// </summary>
            private readonly bool forward;

            /// <summary>
            /// The current node.
            /// </summary>
            private SkipNode current;

            /// <summary>
            /// Initializes a new instance of the <see cref="Iterator"/> struct.
            /// </summary>
            /// <param name="collection">The sortset instnace.</param>
            /// <param name="forward">Whether to traverse from the forward.</param>
            internal Iterator(SortSet<TElement, TScore> collection, bool forward)
            {
                this.collection = collection;
                this.forward = forward;
                current = forward ? collection.header : null;
            }

            /// <inheritdoc />
            public TElement Current
            {
                get
                {
                    return current.Element;
                }
            }

            /// <inheritdoc />
            object IEnumerator.Current
            {
                get
                {
                    return current.Element;
                }
            }

            /// <inheritdoc />
            public void Dispose()
            {
                // ignore.
            }

            /// <inheritdoc />
            public IEnumerator<TElement> GetEnumerator()
            {
                return this;
            }

            /// <inheritdoc />
            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }

            /// <inheritdoc />
            public bool MoveNext()
            {
                if (forward)
                {
                    do
                    {
                        current = current.Level[0].Forward;
                    }
                    while (current != null && current.IsDeleted);
                    return current != null;
                }

                if (current == null)
                {
                    do
                    {
                        current = collection.tail;
                    }
                    while (current != null && current.IsDeleted);
                    return current != null;
                }

                do
                {
                    current = current.Backward;
                }
                while (current != null && current.IsDeleted);
                return current != null;
            }

            /// <inheritdoc />
            void IEnumerator.Reset()
            {
                current = forward ? collection.header : null;
            }
        }

        /// <summary>
        /// Represents a skip node.
        /// </summary>
        private class SkipNode
        {
            /// <summary>
            /// Gets or sets the element.
            /// </summary>
            public TElement Element { get; set; }

            /// <summary>
            /// Gets or sets the score.
            /// </summary>
            public TScore Score { get; set; }

            /// <summary>
            /// Gets or sets a value indicating whether was deleted.
            /// </summary>
            public bool IsDeleted { get; set; }

            /// <summary>
            /// Gets or sets the previous node.
            /// </summary>
            public SkipNode Backward { get; set; }

            /// <summary>
            /// Gets or sets the skip node levels.
            /// </summary>
            public SkipNodeLevel[] Level { get; set; }

            internal struct SkipNodeLevel
            {
                /// <summary>
                /// The next skip node.
                /// </summary>
                internal SkipNode Forward;

                /// <summary>
                /// The number represents how many nodes are crossed with the next node.
                /// </summary>
                internal int Span;
            }
        }
    }
}


================================================
FILE: src/CatLib.Core/Util/Str.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System;
using System.Text;
using System.Text.RegularExpressions;

namespace CatLib.Util
{
    /// <summary>
    /// String helper.
    /// </summary>
    public static class Str
    {
        /// <summary>
        /// The space string.
        /// </summary>
        public const string Space = " ";

        /// <summary>
        /// Fill types.
        /// </summary>
        public enum PadType
        {
            /// <summary>
            /// Fill both sides of the string. If it is not even, the right side gets extra padding.
            /// </summary>
            Both,

            /// <summary>
            /// Fill the left side of the string.
            /// </summary>
            Left,

            /// <summary>
            /// Fill the right side of the string.
            /// </summary>
            Right,
        }

        /// <summary>
        /// Get the method name expressed by the string.
        /// </summary>
        /// <param name="pattern">The string will extract method name.</param>
        /// <returns>The method name.</returns>
        public static string Method(string pattern)
        {
            if (string.IsNullOrEmpty(pattern))
            {
                return string.Empty;
            }

            var chars = new char[pattern.Length];
            var count = 0;
            for (var i = pattern.Length - 1; i >= 0; i--)
            {
                var segment = pattern[i];
                if ((segment >= 'A' && segment <= 'Z')
                    || (segment >= 'a' && segment <= 'z')
                    || (segment >= '0' && segment <= '9')
                    || segment == '_')
                {
                    chars[count++] = segment;
                    continue;
                }

                if (count > 0)
                {
                    break;
                }
            }

            for (var i = count - 1; i >= 0; i--)
            {
                if (chars[i] >= '0' && chars[i] <= '9')
                {
                    count--;
                    continue;
                }

                break;
            }

            Array.Resize(ref chars, count);
            Array.Reverse(chars);
            return new string(chars);
        }

        /// <summary>
        /// Translate the specified string into an asterisk match expression and test.
        /// </summary>
        /// <param name="pattern">The match pattern.</param>
        /// <param name="value">The match value.</param>
        /// <returns>True if value is matched.</returns>
        public static bool Is(string pattern, string value)
        {
            return pattern == value || Regex.IsMatch(value, "^" + AsteriskWildcard(pattern) + "$");
        }

        /// <summary>
        /// Translate the specified string into an asterisk match expression and test.
        /// <para>Returns true if any match patten matches.</para>
        /// </summary>
        /// <typeparam name="T">The type of source array.</typeparam>
        /// <param name="patterns">The match pattern.</param>
        /// <param name="value">The match value.</param>
        /// <returns>True if matches.</returns>
        public static bool Is<T>(string[] patterns, T value)
        {
            if (patterns == null || value == null)
            {
                return false;
            }

            foreach (var pattern in patterns)
            {
                if (Is(pattern, value.ToString()))
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Translate the specified string into an asterisk match expression.
        /// </summary>
        /// <param name="pattern">The match pattern.</param>
        /// <returns>Returns processed string.</returns>
        public static string AsteriskWildcard(string pattern)
        {
            pattern = Regex.Escape(pattern);
            return pattern.Replace(@"\*", ".*?");
        }

        /// <summary>
        /// Splits the string into an array based on length, and the
        /// last element may be less than the required length.
        /// </summary>
        /// <param name="str">The specified string.</param>
        /// <param name="length">Specify the length of each array element.</param>
        /// <returns>Returns an array of the string.</returns>
        public static string[] Split(string str, int length = 1)
        {
            if (string.IsNullOrEmpty(str))
            {
                return Array.Empty<string>();
            }

            length = Math.Max(1, length);
            var ret = new string[(str.Length / length) + (str.Length % length == 0 ? 0 : 1)];
            for (var i = 0; i < str.Length; i += length)
            {
                ret[i / length] = str.Substring(i, Math.Min(str.Length - i, length));
            }

            return ret;
        }

        /// <summary>
        /// Repeat the specified number of times the string.
        /// </summary>
        /// <param name="str">String that needs to be repeated.</param>
        /// <param name="num">Number of repetitions.</param>
        /// <returns>Return the repeated string.</returns>
        public static string Repeat(string str, int num)
        {
            num = Math.Max(0, num);

            if (string.IsNullOrEmpty(str) || num == 0)
            {
                return string.Empty;
            }

            var ret = new StringBuilder();
            for (var i = 0; i < num; i++)
            {
                ret.Append(str);
            }

            return ret.ToString();
        }

        /// <summary>
        /// Shuffle all characters in the string.
        /// </summary>
        /// <param name="str">The specified string.</param>
        /// <param name="seed">The random seed.</param>
        /// <returns>Returns disrupted string.</returns>
        public static string Shuffle(string str, int? seed = null)
        {
            if (string.IsNullOrEmpty(str))
            {
                return string.Empty;
            }

            var random = InternalHelper.MakeRandom(seed);
            var ret = new string[str.Length];
            for (var i = 0; i < str.Length; i++)
            {
                var index = random.Next(0, str.Length - 1);

                ret[i] = ret[i] ?? str.Substring(i, 1);
                ret[index] = ret[index] ?? str.Substring(index, 1);

                if (index == i)
                {
                    continue;
                }

#pragma warning disable S4143
                var temporary = ret[i];
                ret[i] = ret[index];
                ret[index] = temporary;
#pragma warning restore S4143
            }

            return Arr.Reduce(ret, (a, b) => a + b, string.Empty);
        }

        /// <summary>
        /// Calculate the number of times a substring appears in a string.
        /// <para>This function does not count overlapping substrings.</para>
        /// </summary>
        /// <param name="str">The specified string.</param>
        /// <param name="substr">The substring.</param>
        /// <param name="start">The starting position.</param>
        /// <param name="length">The length to calculate.</param>
        /// <param name="comparison">The string comparison.</param>
        /// <returns>Returns the number of times a substring appears. -1 means unable to calculate.</returns>
        public static int SubstringCount(string str, string substr, int start = 0, int? length = null, StringComparison comparison = StringComparison.CurrentCultureIgnoreCase)
        {
            if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(substr))
            {
                return 0;
            }

            InternalHelper.NormalizationPosition(str.Length, ref start, ref length);

            var count = 0;
            while (length.Value > 0)
            {
                int index;
                if ((index = str.IndexOf(substr, start, length.Value, comparison)) < 0)
                {
                    break;
                }

                count++;
                length -= index + substr.Length - start;
                start = index + substr.Length;
            }

            return count;
        }

        /// <summary>
        /// Reverse specified string.
        /// </summary>
        /// <param name="str">The specified string.</param>
        /// <returns>Returns reversed string.</returns>
        public static string Reverse(string str)
        {
            var chars = str.ToCharArray();
            Array.Reverse(chars);
            return new string(chars);
        }

        /// <summary>
        /// Fill the string with the new length.
        /// </summary>
        /// <param name="length">The new string length. If the value is less than the original length of the string, no action is taken.</param>
        /// <param name="str">The string to be filled.</param>
        /// <param name="padStr">A string to be used for padding. The default is blank.</param>
        /// <param name="type">
        /// Fill in which side of the string.
        /// <para><see cref="PadType.Both"/>Fill both sides of the string. If not even, get extra padding on the right side.</para>
        /// <para><see cref="PadType.Left"/>Fill the left side of the string.</para>
        /// <para><see cref="PadType.Right"/>Fill the right side of the string.</para>
        /// </param>
        /// <returns>Returns filled string.</returns>
        public static string Pad(int length, string str = null, string padStr = null, PadType type = PadType.Right)
        {
            str = str ?? string.Empty;

            var needlePadding = length - str.Length;
            if (needlePadding <= 0)
            {
                return str;
            }

            int rightPadding;
            var leftPadding = rightPadding = 0;

            if (type == PadType.Both)
            {
                leftPadding = needlePadding >> 1;
                rightPadding = (needlePadding >> 1) + (needlePadding % 2 == 0 ? 0 : 1);
            }
            else if (type == PadType.Right)
            {
                rightPadding = needlePadding;
            }
            else
            {
                leftPadding = needlePadding;
            }

            padStr = padStr ?? Space;
            padStr = padStr.Length <= 0 ? Space : padStr;

            var leftPadCount = (leftPadding / padStr.Length) + (leftPadding % padStr.Length == 0 ? 0 : 1);
            var rightPadCount = (rightPadding / padStr.Length) + (rightPadding % padStr.Length == 0 ? 0 : 1);

            return Repeat(padStr, leftPadCount).Substring(0, leftPadding) + str +
                   Repeat(padStr, rightPadCount).Substring(0, rightPadding);
        }

        /// <summary>
        /// Finds the specified value in the string and returns the rest.
        /// <para>If not found, return the specified string itself.</para>
        /// </summary>
        /// <param name="str">The specified string.</param>
        /// <param name="search">The search value.</param>
        /// <returns>The remaining part.</returns>
        public static string After(string str, string search)
        {
            if (string.IsNullOrEmpty(str))
            {
                return string.Empty;
            }

            if (string.IsNullOrEmpty(search))
            {
                return str ?? string.Empty;
            }

            var index = str.IndexOf(search, StringComparison.Ordinal);
            return index < 0 ? str : str.Substring(index + search.Length, str.Length - index - search.Length);
        }

        /// <summary>
        /// Determine whether the specified string contains the specified substring.
        /// <para>Substrings are case sensitive.</para>
        /// <para></para>
        /// </summary>
        /// <param name="str">The specified string.</param>
        /// <param name="needles">An array of the specified substring.</param>
        /// <returns>True if contains substring.</returns>
        public static bool Contains(string str, params string[] needles)
        {
            needles = needles ?? Array.Empty<string>();

            foreach (var needle in needles)
            {
                if (str == needle || str.Contains(needle))
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Replace the match in the specified string.
        /// </summary>
        /// <param name="matches">An array of the match string.</param>
        /// <param name="replace">The replacement value.</param>
        /// <param name="str">The specified string.</param>
        /// <returns>Returns the replacement string.</returns>
        public static string Replace(string[] matches, string replace, string str)
        {
            matches = matches ?? Array.Empty<string>();
            replace = replace ?? string.Empty;

            if (string.IsNullOrEmpty(str))
            {
                return string.Empty;
            }

            foreach (var match in matches)
            {
                if (match == null)
                {
                    continue;
                }

                str = str.Replace(match, replace);
            }

            return str;
        }

        /// <summary>
        /// Replace the first occurrence of a match in the specified string.
        /// <para>This function is case sensitive.</para>
        /// </summary>
        /// <param name="match">The match string.</param>
        /// <param name="replace">The replacement value.</param>
        /// <param name="str">The specified string.</param>
        /// <returns>Returns the replacement string.</returns>
        public static string ReplaceFirst(string match, string replace, string str)
        {
            if (string.IsNullOrEmpty(match) || string.IsNullOrEmpty(str))
            {
                return str ?? string.Empty;
            }

            replace = replace ?? string.Empty;
            var index = str.IndexOf(match, StringComparison.Ordinal);
            return index < 0 ? str : str.Remove(index, match.Length).Insert(index, replace);
        }

        /// <summary>
        /// Replaces the first occurrence of a match in the specified string from the back to the front.
        /// <para>This function is case sensitive.</para>
        /// </summary>
        /// <param name="match">The match string.</param>
        /// <param name="replace">The replacement value.</param>
        /// <param name="str">The specified string.</param>
        /// <returns>Returns the replacement string.</returns>
        public static string ReplaceLast(string match, string replace, string str)
        {
            if (string.IsNullOrEmpty(match) || string.IsNullOrEmpty(str))
            {
                return str ?? string.Empty;
            }

            replace = replace ?? string.Empty;
            var index = str.LastIndexOf(match, StringComparison.Ordinal);
            return index < 0 ? str : str.Remove(index, match.Length).Insert(index, replace);
        }

        /// <summary>
        /// Generate a random letter (with case), a string of numbers.
        /// </summary>
        /// <param name="length">The length of the generate string.</param>
        /// <param name="seed">The random seed.</param>
        /// <returns>The random string.</returns>
        public static string Random(int length = 16, int? seed = null)
        {
            length = Math.Max(1, length);

            var ret = new StringBuilder();
            var random = InternalHelper.MakeRandom(seed);
            for (int len; (len = ret.Length) < length;)
            {
                var size = length - len;
                var bytes = new byte[size];
                random.NextBytes(bytes);

                var code = Replace(new[] { "/", "+", "=" }, string.Empty, Convert.ToBase64String(bytes));
                ret.Append(code.Substring(0, Math.Min(size, code.Length)));
            }

            return ret.ToString();
        }

        /// <summary>
        /// If the length exceeds the given maximum string length, the string is truncated.
        /// The last character of the truncated string will be replaced with the mission string.
        /// <para>eg: Str.Truncate("hello world , the sun is shine", 15, Str.Space) => hello world...</para>
        /// </summary>
        /// <param name="str">The string to be truncated.</param>
        /// <param name="length">Truncation length (with default character length).</param>
        /// <param name="separator">The adjacent separator, if set, truncates the separator position with the length of the truncation length, and uses a regular match if a regular expression is passed.</param>
        /// <param name="mission">The mission string.</param>
        /// <returns>Reutrns truncated string.</returns>
        public static string Truncate(string str, int length, object separator = null, string mission = null)
        {
            if (str == null || length > str.Length)
            {
                return str;
            }

            mission = mission ?? "...";
            var end = length - mission.Length;

            if (end < 1)
            {
                return mission;
            }

            var ret = str.Substring(0, end);

            if (separator == null)
            {
                return ret + mission;
            }

            var separatorStr = separator.ToString();
            var index = -1;
            if (separator is Regex separatorRegex)
            {
                if (separatorRegex.IsMatch(ret))
                {
                    index = (separatorRegex.RightToLeft
                        ? separatorRegex.Match(ret)
                        : Regex.Match(ret, separatorRegex.ToString(),
                            separatorRegex.Options | RegexOptions.RightToLeft)).Index;
                }
            }
            else if (!string.IsNullOrEmpty(separatorStr) && str.IndexOf(separatorStr, StringComparison.Ordinal) != end)
            {
                index = ret.LastIndexOf(separatorStr, StringComparison.Ordinal);
            }

            if (index > -1)
            {
                ret = ret.Substring(0, index);
            }

            return ret + mission;
        }

        /// <summary>
        /// Calculate Levenshtein distance between two strings.
        /// </summary>
        /// <param name="a">The string 1.</param>
        /// <param name="b">The string 2.</param>
        /// <returns>
        /// This function returns the Levenshtein-Distance between the two argument
        /// strings or -1, if one of the argument strings is longer than the limit
        /// of 255 characters.
        /// </returns>
        public static int Levenshtein(string a, string b)
        {
            if (a == null || b == null)
            {
                return -1;
            }

            var lengthA = a.Length;
            var lengthB = b.Length;

            if (lengthA > 255 || lengthB > 255)
            {
                return -1;
            }

            var pA = new int[lengthB + 1];
            var pB = new int[lengthB + 1];

            for (var i = 0; i <= lengthB; i++)
            {
                pA[i] = i;
            }

            int Min(int num1, int num2, int num3)
            {
                var min = num1;
                if (min > num2)
                {
                    min = num2;
                }

                if (min > num3)
                {
                    min = num3;
                }

                return min;
            }

            for (var i = 0; i < lengthA; i++)
            {
                pB[0] = pA[0] + 1;
                for (var n = 0; n < lengthB; n++)
                {
                    var distance = a[i] == b[n]
                        ? Min(pA[n], pA[n + 1] + 1, pB[n] + 1)
                        : Min(pA[n] + 1, pA[n + 1] + 1, pB[n] + 1);
                    pB[n + 1] = distance;
                }

                var temp = pA;
                pA = pB;
                pB = temp;
            }

            return pA[lengthB];
        }

        /// <summary>
        /// Returns all sequential combination of the given array.
        /// </summary>
        /// <remarks>
        /// v[0] = "hello"
        /// v[1] = "world"
        /// var result = Str.JoinList(v, "/");
        /// result[0] == "hello";
        /// result[1] == "hello/world";.
        /// </remarks>
        /// <param name="sources">The source array.</param>
        /// <param name="separator">The separator.</param>
        /// <returns>The sequential combination array.</returns>
        public static string[] JoinList(string[] sources, string separator = null)
        {
            sources = sources ?? Array.Empty<string>();
            var ret = new StringBuilder();
            for (var index = 1; index < sources.Length; index++)
            {
                ret.Append(sources[index - 1]);
                if (!string.IsNullOrEmpty(separator))
                {
                    ret.Append(separator);
                }

                ret.Append(sources[index]);
                sources[index] = ret.ToString();
                ret.Remove(0, sources[index].Length);
            }

            return sources;
        }

        /// <inheritdoc cref="JoinList(string[], char)"/>
        public static string[] JoinList(string[] source, char separator)
        {
            return JoinList(source, separator.ToString());
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/CatLib/TestsApplication.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using CatLib.EventDispatcher;
using CatLib.Exception;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using System.Diagnostics;
using System.Reflection;
using System.Threading.Tasks;

namespace CatLib.Tests
{
    [TestClass]
    public class TestsApplication
    {
        private Application application;
        private IEventDispatcher dispatcher;

        [TestInitialize]
        public void Initialize()
        {
            application = new Application();
            dispatcher = application.Make<IEventDispatcher>();
        }

        [TestMethod]
        public void TestGetFileVersion()
        {
            var expected = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion;
            Assert.AreEqual(expected, Application.Version);
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestBootstrapRepeat()
        {
            application.Bootstrap();
            application.Init();
            application.Bootstrap();
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestInitRepeat()
        {
            application.Bootstrap();
            application.Init();
            application.Init();
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestInitNoBootstrap()
        {
            application.Init();
        }

        [TestMethod]
        public void TestBootstrapSkip()
        {
            var foo = new Mock<IBootstrap>();
            var bar = new Mock<IBootstrap>();

            dispatcher.AddListener(ApplicationEvents.OnBooting, (sender, eventArgs) =>
            {
                if (eventArgs is BootingEventArgs args &&
                    args.GetBootstrap() == foo.Object)
                {
                    args.Skip();
                }
            });

            application.Bootstrap(foo.Object, bar.Object);

            foo.Verify((o) => o.Bootstrap(), Times.Never);
            bar.Verify((o) => o.Bootstrap(), Times.Once);
        }

        [TestMethod]
        public void TestRegisterSkip()
        {
            var foo = new Mock<IServiceProvider>();
            var bar = new Mock<IServiceProvider>();

            dispatcher.AddListener(ApplicationEvents.OnRegisterProvider, (sender, eventArgs) =>
            {
                if (eventArgs is RegisterProviderEventArgs args &&
                    args.GetServiceProvider() == foo.Object)
                {
                    args.Skip();
                }
            });

            application.Register(foo.Object);
            application.Register(bar.Object);

            foo.Verify((o) => o.Register(), Times.Never);
            bar.Verify((o) => o.Register(), Times.Once);
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestRegisterRepeat()
        {
            var foo = new Mock<IServiceProvider>();
            application.Register(foo.Object);
            application.Register(foo.Object);
        }

        [TestMethod]
        [ExpectedExceptionAndMessage(typeof(LogicException))]
        public void TestInitingRegister()
        {
            var foo = new Mock<IServiceProvider>();
            var bar = new Mock<IServiceProvider>();

            dispatcher.AddListener(ApplicationEvents.OnInitProvider, (sender, eventArgs) =>
            {
                application.Register(foo.Object);
            });

            application.Register(bar.Object);
            application.Bootstrap();
            application.Init();
        }

        [TestMethod]
        [ExpectedExceptionAndMessage(typeof(LogicException))]
        public void TestTerminateRegister()
        {
            var foo = new Mock<IServiceProvider>();

            dispatcher.AddListener(ApplicationEvents.OnBeforeTerminate, (sender, eventArgs) =>
            {
                application.Register(foo.Object);
            });

            application.Bootstrap();
            application.Init();
            application.Terminate();
        }

        [TestMethod]
        public void TestTerminateSequenceOfEvents()
        {
            var count = 0;
            dispatcher.AddListener(ApplicationEvents.OnBeforeTerminate, (sender, eventArgs) =>
            {
                Assert.AreEqual(0, count++);
            });

            dispatcher.AddListener(ApplicationEvents.OnAfterTerminate, (sender, eventArgs) =>
            {
                Assert.AreEqual(1, count++);
            });

            application.Terminate();
            Assert.AreEqual(2, count);
        }

        [TestMethod]
        public void TestGetProcess()
        {
            Assert.AreEqual(StartProcess.Construct, application.Process);
        }

        [TestMethod]
        [DataRow(DebugLevel.Development)]
        [DataRow(DebugLevel.Production)]
        [DataRow(DebugLevel.Staging)]
        public void TestDebugLevel(DebugLevel expected)
        {
            application.DebugLevel = expected;
            Assert.AreEqual(expected, application.DebugLevel);
        }

        [TestMethod]
        public void TestGetRuntimeId()
        {
            Assert.AreNotEqual(application.GetRuntimeId(), application.GetRuntimeId());
        }

        [TestMethod]
        public async Task TestIsMainThread()
        {
            Assert.AreEqual(true, application.IsMainThread);
            await Task.Run(() =>
            {
                Assert.AreEqual(false, application.IsMainThread);
            }).ConfigureAwait(false);
        }

        [TestMethod]
        public void TestInitAfterRegister()
        {
            var foo = new Mock<IServiceProvider>();
            var bar = new Mock<IServiceProvider>();

            application.Bootstrap();
            application.Register(foo.Object);
            application.Init();
            application.Register(bar.Object);

            foo.Verify((o) => o.Register(), Times.Once);
            bar.Verify((o) => o.Register(), Times.Once);
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestRegistingMake()
        {
            var foo = new Mock<IServiceProvider>();
            foo.Setup((o) => o.Register()).Callback(() =>
            {
                application.Make("foo");
            });

            application.Register(foo.Object);
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestBoostrapRepeat()
        {
            var foo = new Mock<IBootstrap>().Object;
            application.Bootstrap(foo, foo);
        }

        [TestMethod]
        public void TestBoostrapOrder()
        {
            var foo = new Mock<IBootstrap>();
            var bar = new Mock<IBootstrap>();
            var baz = new Mock<IBootstrap>();

            var count = 0;
            foo.Setup((o) => o.Bootstrap()).Callback(() =>
            {
                Assert.AreEqual(0, count++);
            });

            bar.Setup((o) => o.Bootstrap()).Callback(() =>
            {
                Assert.AreEqual(1, count++);
            });

            baz.Setup((o) => o.Bootstrap()).Callback(() =>
            {
                Assert.AreEqual(2, count++);
            });

            application.Bootstrap(foo.Object, bar.Object, baz.Object);
            Assert.AreEqual(3, count);
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/CatLib/TestsFacade.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using CatLib.Tests.Fixture;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace CatLib.Tests
{
    [TestClass]
    public class TestsFacade
    {
        private Application application;

        [TestInitialize]
        public void Initialize()
        {
            application = Application.New();
            application.Bootstrap();
        }

        [TestMethod]
        public void TestFacade()
        {
            application.Singleton<IFoo, Foo>();
            var foo = Facade<IFoo>.That;

            Assert.AreSame(foo, Facade<IFoo>.That);
        }

        [TestMethod]
        public void TestAlwaysWatchNewer()
        {
            application.Singleton<IFoo, Foo>();
            var older = Facade<IFoo>.That;

            application.Unbind<IFoo>();
            application.Singleton<IFoo, Foo>();
            var newer = Facade<IFoo>.That;

            Assert.AreNotSame(older, newer);
        }

        [TestMethod]
        public void TestAlwaysWatchWithInstance()
        {
            application.Singleton<IFoo, Foo>();
            Assert.AreNotEqual(null, Facade<IFoo>.That);

            var foo = new Foo();
            application.Instance<IFoo>(foo);
            Assert.AreSame(foo, Facade<IFoo>.That);
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestFacadeMakeFaild()
        {
            application.Singleton<IFoo, Foo>();
            Assert.AreNotEqual(null, Facade<IFoo>.That);

            application.Unbind<IFoo>();
            _ = Facade<IFoo>.That;
        }

        [TestMethod]
        public void TestFacadeRelease()
        {
            application.Singleton<IFoo, Foo>();

            var foo = Facade<IFoo>.That;
            Assert.AreSame(foo, Facade<IFoo>.That);

            application.Release<IFoo>();
            Assert.AreNotSame(foo, Facade<IFoo>.That);
        }

        [TestMethod]
        public void TestNotStaticBindFacade()
        {
            application.Bind<IFoo, Foo>();

            var foo = Facade<IFoo>.That;
            Assert.AreNotSame(foo, Facade<IFoo>.That);
        }

        [TestMethod]
        public void TestSingletonChangeToBind()
        {
            application.Singleton<IFoo, Foo>();

            var foo = Facade<IFoo>.That;
            Assert.AreSame(foo, Facade<IFoo>.That);

            application.Unbind<IFoo>();
            application.Bind<IFoo, Foo>();

            Assert.AreNotSame(foo, Facade<IFoo>.That);
            Assert.AreNotSame(Facade<IFoo>.That, Facade<IFoo>.That);
        }

        [TestMethod]
        public void TestBindChangeToSingleton()
        {
            application.Bind<IFoo, Foo>();

            var foo = Facade<IFoo>.That;
            Assert.AreNotSame(foo, Facade<IFoo>.That);

            application.Unbind<IFoo>();
            application.Singleton<IFoo, Foo>();

            Assert.AreNotSame(foo, Facade<IFoo>.That);
            Assert.AreSame(Facade<IFoo>.That, Facade<IFoo>.That);
        }

        [TestMethod]
        public void TestInstance()
        {
            application.Instance<IFoo>(new Foo());

            var foo = Facade<IFoo>.That;
            Assert.AreSame(foo, Facade<IFoo>.That);
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/CatLib.Core.Tests.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netcoreapp3.0</TargetFramework>
    <IsPackable>false</IsPackable>
    <Version>2.0.0</Version>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\CatLib.Core\CatLib.Core.csproj" />
  </ItemGroup>

</Project>


================================================
FILE: src/CatLib.Core.Tests/Container/TestsBindData.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using CatLib.Exception;
using CatLib.Tests.Fixture;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using CContainer = CatLib.Container.Container;

namespace CatLib.Tests.Container
{
    [TestClass]
    public class TestsBindData
    {
        private CContainer container;
        private BindData bindData;

        [TestInitialize]
        public void Init()
        {
            container = new CContainer();
            bindData = (BindData)container.Bind("foo", (container, args) => "foo", true);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void CheckNeedsIllegal()
        {
            bindData.Needs(null);
        }

        [TestMethod]
        public void TestGetContextual()
        {
            bindData.Needs("foo").Given("bar");
            Assert.AreEqual("bar", bindData.GetContextual("foo"));

            bindData.Needs("bar").Given<Foo>();
            Assert.AreEqual(container.Type2Service(typeof(Foo)), bindData.GetContextual("bar"));
        }

        [TestMethod]
        public void TestGetContextualClosure()
        {
            bindData.Needs("foo").Given(() => "foo");

            Assert.AreEqual("foo", bindData.GetContextualClosure("foo")());
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestNeedsDuplicate()
        {
            bindData.Needs("foo").Given("bar");
            bindData.Needs("foo").Given("baz");
        }

        [TestMethod]
        public void TestAlias()
        {
            bindData.Alias("foo-alias");
            bindData.Alias<IFoo>();

            Assert.AreSame(bindData, container.GetBind("foo-alias"));
            Assert.AreSame(bindData, container.GetBind<IFoo>());
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void TestAliasIllegal()
        {
            bindData.Alias(null);
        }

        [TestMethod]
        public void TestTag()
        {
            bindData.Tag("tag");
            CollectionAssert.AreEqual(new[] { "foo" }, container.Tagged("tag"));
        }

        [TestMethod]
        public void TestOnRelease()
        {
            var count = 0;
            bindData.OnRelease((binder, instance) =>
            {
                Assert.AreEqual("foo", instance);
                Assert.AreSame(bindData, binder);
                count++;
            });

            bindData.OnRelease(() =>
            {
                count++;
            });

            container.Make("foo");
            container.Release("foo");
            Assert.AreEqual(2, count);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void TestOnReleaseIllegal()
        {
            bindData.OnRelease(null);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void TestOnResolvingIllegal()
        {
            bindData.OnResolving(null);
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestUnbind()
        {
            Assert.AreEqual("foo", container.Make("foo"));
            bindData.Unbind();
            container.Make("foo");
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestUnbindAfterChanged()
        {
            bindData.Unbind();
            bindData.Alias("foo-alias");
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Container/TestsContainer.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using CatLib.Exception;
using CatLib.Tests.Fixture;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Linq;
using CContainer = CatLib.Container.Container;
using SException = System.Exception;

namespace CatLib.Tests.Container
{
    [TestClass]
    public class TestsContainer
    {
        private IContainer container;

        [TestInitialize]
        public void Initialize()
        {
            container = CreateContainer();

            container.OnFindType((service) =>
            {
                return Type.GetType(service);
            });
        }

        [TestMethod]
        public void TestTag()
        {
            var foo = new Foo();
            container["baz"] = 100;
            container["bar"] = 200;

            var service = container.Type2Service(typeof(Foo));
            container.Bind(service, (container, args) => foo, false);

            container.Tag("tag", service);
            container.Tag("tag", "baz", "bar");

            CollectionAssert.AreEqual(
                new object[] { foo, 100, 200 },
                container.Tagged("tag"));
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentNullException))]
        public void TestTagIllegal()
        {
            container.Tag(string.Empty);
            container.Tag(null);
        }

        [TestMethod]
        [ExpectedExceptionAndMessage(
            typeof(LogicException),
            "Tag \"foo\" is not exist.")]
        public void TestTagNotExists()
        {
            container.Tagged("foo");
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestUnbind()
        {
            container.Bind("foo", (app, args) => "foo", false);
            container.Unbind("foo");
            container.Make("foo");
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestUnbindWithAlias()
        {
            container.Bind("bar", (app, args) => "bar", false).Alias("baz");
            container.Unbind("baz");
            container.Make("baz");
        }

        [TestMethod]
        [DataRow(typeof(string[]))]
        [DataRow(typeof(AbstractClass))]
        [DataRow(typeof(IFoo))]
        [ExpectedExceptionAndMessage(typeof(LogicException), "can not bind.")]
        public void TestUnableType(Type type)
        {
            container.Bind("foo", type, false);
        }

        [TestMethod]
        public void TestBindIf()
        {
            var foo = container.BindIf("foo", (container, args) => "foo", true, out IBindData bindFoo);
            var bar = container.BindIf("foo", (container, args) => "bar", true, out IBindData bindBar);

            Assert.AreSame(bindFoo, bindBar);
            Assert.AreEqual(true, foo);
            Assert.AreEqual(false, bar);
        }

        [TestMethod]
        public void TestbBindIfWithType()
        {
            var foo = container.BindIf("foo", typeof(Foo), true, out IBindData bindFoo);
            var bar = container.BindIf("foo", typeof(Bar), true, out IBindData bindBar);

            Assert.AreSame(bindFoo, bindBar);
            Assert.AreEqual(true, foo);
            Assert.AreEqual(false, bar);
        }

        [TestMethod]
        public void TestBindStatic()
        {
            container.Bind("foo", (container, args) => new Foo(), true);

            var fooBind = container.GetBind("foo");
            var foo = container.Make("foo");

            Assert.AreNotEqual(null, fooBind);
            Assert.AreEqual(true, fooBind.IsStatic);
            Assert.AreSame(foo, container.Make("foo"));
        }

        [TestMethod]
        public void TestBindNonStatic()
        {
            container.Bind("foo", (container, args) => new Foo(), false);
            var older = container.Make("foo");
            var newer = container.Make("foo");

            Assert.AreNotSame(older, newer);
        }

        [TestMethod]
        public void TestGetBind()
        {
            var fooBind = container.Bind("foo", (container, args) => "foo", false);
            var getBind = container.GetBind("foo");
            Assert.AreSame(fooBind, getBind);

            getBind = container.GetBind("non-service");
            Assert.AreEqual(null, getBind);

            container.Alias("foo-alias", "foo");
            getBind = container.GetBind("foo-alias");
            Assert.AreEqual(fooBind, getBind);

            getBind = container.GetBind(null);
            Assert.AreEqual(null, getBind);
        }

        [TestMethod]
        public void TestBindIllegal()
        {
            container.Bind("foo", (container, args) => "foo", true);

            Assert.ThrowsException<LogicException>(() =>
            {
                container.Bind("foo", (container, args) => "repeat bind", false);
            });

            container.Instance("bar", "bar");
            Assert.ThrowsException<LogicException>(() =>
            {
                container.Bind("bar", (container, args) => "instance repeat bind", false);
            });

            container.Alias("foo-alias", "foo");
            Assert.ThrowsException<LogicException>(() =>
            {
                container.Bind("foo-alias", (container, args) => "alias repeat bind", false);
            });

            Assert.ThrowsException<ArgumentNullException>(() =>
            {
                container.Bind(null, (container, args) => "invalid service name", false);
            });

            Assert.ThrowsException<LogicException>(() =>
            {
                container.Bind("$foo", (container, args) => "Illegal placeholder", false);
            });
        }

        [TestMethod]
        public void TestHasBind()
        {
            container.Bind("foo", (container, args) => "foo", false)
                     .Alias("foo-alias");

            Assert.IsTrue(container.HasBind("foo"));
            Assert.IsTrue(container.HasBind("foo-alias"));
        }

        [TestMethod]
        public void TestIsStatic()
        {
            container.Bind("foo", (container, args) => "foo", true)
                     .Alias("foo-alias");

            container.Bind("bar", (container, args) => "bar", false)
                     .Alias("bar-alias");

            Assert.IsTrue(container.IsStatic("foo"));
            Assert.IsTrue(container.IsStatic("foo-alias"));
            Assert.IsFalse(container.IsStatic("bar"));
            Assert.IsFalse(container.IsStatic("bar-alias"));
        }

        [TestMethod]
        public void TestAlias()
        {
            container.Bind("foo", (container, args) => "foo", false)
                     .Alias("foo-alias");

            container.Instance("bar", "bar");
            container.Alias("bar-alias", "bar");

            Assert.AreEqual("foo", container["foo-alias"]);
            Assert.AreEqual("bar", container["bar-alias"]);
        }

        [TestMethod]
        [DataRow("bar-alias", "bar", typeof(LogicException), "Set an alias for a service that does not exist.")]
        [DataRow(null, "bar", typeof(ArgumentNullException), "Alias name is null.")]
        [DataRow("baz", null, typeof(ArgumentNullException), "Service name is null.")]
        [DataRow("foo", "foo", typeof(LogicException), "Alias is same as service")]
        public void TestAliasIllegal(string alias, string service, Type expected, string reason)
        {
            container.Bind("foo", (container, args) => "foo", false)
                     .Alias("foo-alias");

            try
            {
                container.Alias(alias, service);
                Assert.Fail(reason);
            }
            catch (SException ex) when (ex.GetType() != expected)
            {
                Assert.Fail($"Expected throw an exception: {expected}, actual throw: {ex}");
            }
#pragma warning disable CA1031
            catch (SException)
#pragma warning restore CA1031
            {
                // test passed.
            }
        }

        [TestMethod]
        [ExpectedExceptionAndMessage(typeof(LogicException), "Circular dependency detected while for")]
        public void TestCircularDependencyInject()
        {
            container.Bind("foo", typeof(CircularDependency), false);
            container.Make("foo");
        }

        [TestMethod]
        public void TestIsAlias()
        {
            container.Bind("foo", (container, args) => "foo", false)
                     .Alias("foo-alias");

            Assert.IsTrue(container.IsAlias("foo-alias"));
            Assert.IsFalse(container.IsAlias("foo"));
        }

        [TestMethod]
        [DataRow(null)]
        [DataRow(new[] { "unless-parameter" })]
        public void TestCall(string[] userParams)
        {
            var serviceFoo = container.Type2Service(typeof(Foo));
            var serviceBar = container.Type2Service(typeof(Bar));

            container.Bind(serviceFoo, typeof(Foo), true);
            container.Bind(serviceBar, typeof(Bar), true);

            var fooBar = FooBar.New();
            var methodInfo = fooBar.GetType().GetMethod(nameof(fooBar.GetName));
            Assert.AreEqual("foobar", container.Call(fooBar, methodInfo, userParams));
        }

        [TestMethod]
        [ExpectedExceptionAndMessage(typeof(LogicException), "Circular dependency detected while for")]
        public void TestCallCircularDependencyInject()
        {
            var service = container.Type2Service(typeof(CircularDependency));
            container.Bind(service, typeof(CircularDependency), false);

            var foo = new CircularDependency(null);
            container.Call(foo, foo.GetType().GetMethod(nameof(foo.Foo)));
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestCallGivenIncorrectParament()
        {
            container.Bind("num", (container, args) => "foo", true)
                     .Alias("$num");

            Action<int> action = (int num) =>
            {
                Assert.Fail("Should throw UnresolvableException exception.");
            };

            container.Call(action.Target, action.Method);
        }

        [TestMethod]
        [ExpectedExceptionAndMessage(
            typeof(LogicException),
            "Too many parameters , must be less or equal than 255")]
        public void TestMakearameterOverflow()
        {
            container.Bind("foobar", typeof(FooBar), false);
            container.Make("foobar", new object[256]);
        }

        [TestMethod]
        public void TestTightInject()
        {
            Action<object[], Foo, Bar> action = (objs, foo, bar) =>
            {
                Assert.AreEqual(100, objs[0]);
                Assert.AreEqual("foo", objs[1]);
                Assert.AreNotEqual(null, foo);
                Assert.AreNotEqual(null, bar);
            };

            container.Call(action.Target, action.Method, 100, "foo");
        }

        [TestMethod]
        public void TestContextInjectionWithProperty()
        {
            var service = container.Type2Service(typeof(Baz));
            container.Bind(service, typeof(Baz), false)
                     .Needs("$Name").Given(() => "bazbaz")
                     .Needs("$Qux").Given(() => 100);

            var baz = (Baz)container.Make(service);
            Assert.AreEqual("bazbaz", baz.Name);
        }

        [TestMethod]
        public void TestContextInjection()
        {
            container.Bind("baz", typeof(Baz), false)
                     .Needs("$boo").Given(() => 500)
                     .Needs("$Qux").Given(() => 100);

            var baz = (Baz)container.Make("baz");
            Assert.AreEqual(500, baz.Boo);

            container.Bind("baz-cast-type", typeof(Baz), false)
                     .Needs("$boo").Given(() => "300")
                     .Needs("$Qux").Given(() => 100);
            baz = (Baz)container.Make("baz-cast-type");
            Assert.AreEqual(300, baz.Boo);
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestContextInjectionErrorType()
        {
            container = CreateContainer();
            container.Bind("foobar", typeof(FooBar), false)
                     .Needs("$foo").Given(() => new Bar());
            container.Make("foobar");
        }

        [TestMethod]
        public void TestMake()
        {
            var service = container.Type2Service(typeof(FooBar));
            container.Bind(service, typeof(FooBar), true);
            var foobar = container.Make(service);
            Assert.AreNotEqual(null, foobar);
        }

        [TestMethod]
        public void TestMakeWithParams()
        {
            container.Bind("baz", typeof(Baz), false)
                     .Needs("$Qux").Given(() => 100);
            var baz = (Baz)container.Make("baz", 500);
            Assert.AreEqual(500, baz.Boo);
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestMakeEmptyService()
        {
            container.Make(string.Empty);
        }

        [TestMethod]
        public void TestMakeWithAlias()
        {
            container.Bind("foo", typeof(Foo), true).Alias("foo-alias");
            container.Bind("bar", typeof(Bar), true).Alias("bar-alias");

            var foo = container.Make("foo");
            var bar = container.Make("bar");

            Assert.AreSame(foo, container.Make("foo-alias"));
            Assert.AreSame(bar, container.Make("bar-alias"));
        }

        [TestMethod]
        [ExpectedException(
            typeof(UnresolvableException),
            "Unresolvable dependency , resolving [Name] in class")]
        public void TestMakeAttributeInjectFaild()
        {
            container = CreateContainer();
            container.Bind("baz", typeof(Baz), true)
                     .Needs("$Qux").Given(() => 100);
            container.Make("baz", new Foo());
        }

        [TestMethod]
        [ExpectedExceptionAndMessage(
            typeof(UnresolvableException),
            "Unresolvable dependency , resolving [Qux] in class")]
        public void TestMakeAttributeInjectFaildWithPrimitiveAttr()
        {
            container.Bind("baz", typeof(Baz), true);
            container.Make("baz", new Foo());
        }

        [TestMethod]
        public void TestMakeWithDefaultValuePrimitive()
        {
            container.Bind("baz", typeof(Baz), true)
                     .Needs("$Qux").Given(() => 500);
            var baz = (Baz)container.Make("baz");
            Assert.AreEqual(100, baz.Boo);
        }

        [TestMethod]
        public void TestMakeWithDefaultValue()
        {
            container = CreateContainer();
            container.Bind("fubar", typeof(Fubar), true);

            var fubar = (Fubar)container.Make("fubar");
            Assert.AreEqual(null, fubar.Bar);
        }

        [TestMethod]
        public void TestMakeInjectWithStruct()
        {
            var service = container.Type2Service(typeof(Position));
            container.Bind("fubar", typeof(Fubar), true);
            container.Bind(service, (container, args) => new Position()
            {
                X = 1,
                Y = 2,
            });

            var fubar = (Fubar)container.Make("fubar");

            Assert.AreEqual(1, fubar.Position.X);
            Assert.AreEqual(2, fubar.Position.Y);
        }

        [TestMethod]
        public void TestMakeInjectWithGeneric()
        {
            container = CreateContainer();
            container.Bind("fubar", typeof(Fubar), true);
            var service = container.Type2Service(typeof(IList<string>));
            container.Bind(service, (container, args) => new List<string>()
            {
                "iron man",
                "black window",
            });
            service = container.Type2Service(typeof(IList<int>));
            container.Bind(service, (container, args) => new List<int>()
            {
                25,
                23,
            });

            var fubar = (Fubar)container.Make("fubar");

            CollectionAssert.AreEqual(
                new[] { "iron man", "black window" },
                fubar.Heros.ToArray());

            CollectionAssert.AreEqual(
                new[] { 25, 23 },
                fubar.Ages.ToArray());

            Assert.AreEqual(null, fubar.Bar);
        }

        [TestMethod]
        [ExpectedExceptionAndMessage(
            typeof(LogicException),
            "can not bind.")]
        public void TestMakeAbstractClass()
        {
            container.Bind("foo", typeof(AbstractClass), true);
            container.Make("foo");
        }

        [TestMethod]
        public void TestMakeInjectWithInheritance()
        {
            var service = container.Type2Service(typeof(IList<string>));
            container.Bind("fubar", typeof(Fubar), true);
            container.Bind(service, (container, args) => new List<string>()
            {
                "iron man",
                "black window",
            });

            var fubar = (Fubar)container.Make("fubar");

            CollectionAssert.AreEqual(
                new[] { "iron man", "black window" },
                fubar.Heros.ToArray());

            Assert.AreNotEqual(null, fubar.Bar);
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestMakeMissConstructor()
        {
            container.Bind("quux", typeof(Quux), true);
            container.Make("quux");
        }

        [TestMethod]
        [ExpectedExceptionAndMessage(typeof(TestException), "QuuxFoo")]
        public void TestMakeConstructorThrowException()
        {
            container.Bind("foo", typeof(QuuxFoo), false);
            container.Make("foo");
        }

        [TestMethod]
        public void TestMakeWithIParams()
        {
            container = CreateContainer();
            container.Bind("foobar", typeof(FooBar), false);

            var foo = new Foo();
            var bar = new Bar();
            var foobar = (FooBar)container.Make(
                "foobar",
                new ParamsCollection
                {
                    { "foo", foo },
                }, bar);

            Assert.AreEqual("foobar", foobar.ToString());
            Assert.AreSame(foo, foobar.Foo);
            Assert.AreSame(bar, foobar.Bar);
        }

        [TestMethod]
        public void TestMakeWithMultIParamsOrder()
        {
            container = CreateContainer();
            container.Bind("foobar", typeof(FooBar), false);

            var foo1 = new Foo();
            var bar1 = new Bar();
            var foo2 = new Foo();
            var bar2 = new Bar();
            var foobar = (FooBar)container.Make(
                "foobar",
                new ParamsCollection
            {
                { "foo", foo1 },
                { "bar", bar1 },
            }, new ParamsCollection
            {
                { "foo", foo2 },
            }, bar2);

            Assert.AreEqual("foobar", foobar.ToString());
            Assert.AreSame(foo1, foobar.Foo);
            Assert.AreSame(bar1, foobar.Bar);
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestMakeWithIParamsGivenErrorType()
        {
            container = CreateContainer();
            container.Bind("foobar", typeof(FooBar), false);

            container.Make("foobar", new ParamsCollection
                {
                    { "foo", new Bar() },
                    { "bar", new Foo() },
                });
        }

        [TestMethod]
        public void TestMakeNullable()
        {
            container.Bind("bar", typeof(Bar), false)
                     .Needs("$Age").Given(() => 24);
            var bar = (Bar)container.Make("bar");

            Assert.IsFalse(bar.Num.HasValue);
            Assert.AreEqual(24, bar.Age.Value);
        }

        [TestMethod]
        public void TestCanMake()
        {
            Assert.IsFalse(container.CanMake("foo"));
            Assert.IsTrue(container.CanMake<Foo>());

            container = CreateContainer();
            Assert.IsFalse(container.CanMake<Foo>());
        }

        [TestMethod]
        public void TestInstance()
        {
            var bar = new object();
            container.Instance("foo", "foo");
            container.Instance("bar", bar);

            Assert.AreEqual("foo", container.Make("foo"));
            Assert.AreSame(bar, container.Make("bar"));

            // double checked
            Assert.AreSame(bar, container.Make("bar"));
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        [DataRow("foo:bar")]
        [DataRow("$foo")]
        [DataRow("foo@bar")]
        public void TestInstanceIllegalChars(string service)
        {
            container.Instance(service, "illegal chars");
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestInstanceNotAllowedSameObject()
        {
            var foo = new object();
            container.Instance("foo", foo);
            container.Instance("bar", foo);
        }

        [TestMethod]
        public void TestInstanceAllowedDifferenceObject()
        {
            container.Instance("foo", "foo");
            container.Instance("bar", "bar");
        }

        [TestMethod]
        [ExpectedException(
            typeof(LogicException),
            "is not Singleton(Static) Bind.")]
        public void TestInstanceIllegal()
        {
            container.Bind("foo", typeof(Foo), false);
            container.Instance("foo", "foo");
        }

        [TestMethod]
        public void TestReleaseAutoCallDispose()
        {
            container.Bind("bar", typeof(Bar), true);
            var bar = (Bar)container.Make("bar");

            Assert.IsFalse(bar.Disposed);
            container.Release("bar");
            Assert.IsTrue(bar.Disposed);
        }

        [TestMethod]
        public void TestOnRelease()
        {
            var count = 0;
            container.Bind("foo", typeof(Foo), true)
                     .OnRelease((binder, instance) =>
                     {
                         Assert.AreEqual(typeof(Foo), instance.GetType());
                         count++;
                     });

            container.Make("foo");
            container.Release("foo");

            container = CreateContainer();
            container.Instance("foo", "foo");
            container.OnRelease((binder, instance) =>
            {
                Assert.AreEqual("foo", instance);
                count++;
            });
            container.Release("foo");

            Assert.AreEqual(2, count);
        }

        [TestMethod]
        public void TestFlush()
        {
            container["foo"] = "foo";
            container["bar"] = "bar";
            container["baz"] = "baz";

            container.Flush();

            Assert.ThrowsException<UnresolvableException>(() =>
            {
                container.Make("foo");
            });

            Assert.ThrowsException<UnresolvableException>(() =>
            {
                container.Make("bar");
            });

            Assert.ThrowsException<UnresolvableException>(() =>
            {
                container.Make("baz");
            });
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestFlushInstanceService()
        {
            container.Bind("foo", typeof(Foo), true)
                     .OnRelease((binder, instance) =>
                     {
                         container.Instance("bar", "bar");
                     });

            container.Make("foo");
            container.Flush();
        }

        [TestMethod]
        public void TestFlushOrder()
        {
            var foo = container.Type2Service(typeof(Foo));
            var bar = container.Type2Service(typeof(Bar));
            container.Bind(foo, typeof(Foo), true);
            container.Bind(bar, typeof(Bar), true);
            container.Bind("foobar", typeof(FooBar), true);

            var actual = new List<Type>();
            container.OnRelease((binder, instance) =>
            {
                actual.Add(instance.GetType());
            });

            container.Make("foobar");
            container.Flush();

            CollectionAssert.AreEqual(
                new[]
                {
                    typeof(FooBar),
                    typeof(Bar),
                    typeof(Foo),
                }, actual);
        }

        [TestMethod]
        public void TestVariant()
        {
            container.Bind("foo", typeof(Variant), false);

            var foo = (Variant)container.Make("foo", 1);
            Assert.AreEqual("iron man", foo.Model.Name);

            foo = (Variant)container.Make("foo", 2);
            Assert.AreEqual("black window", foo.Model.Name);
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestVariantThrowException()
        {
            container.Bind("foo", typeof(Variant), false);
            container.Make("foo", -1);
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestVariantForceGivenNull()
        {
            container.Bind("foo", typeof(Variant), false);
            container.Make("foo", new ParamsCollection
                {
                    { "model", null },
                });
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestReboundNotExistsService()
        {
            container.OnRebound("foobar", (instance) =>
            {
            });
        }

        [TestMethod]
        public void TestRebound()
        {
            var count = 0;
            var binder = container.Bind("foo", (container, args) => "foo");
            container.OnRebound("foo", (instance) =>
            {
                Assert.AreEqual("bar", instance);
                count++;
            });

            binder.Unbind();

            // first built don't trigger OnRebound.
            binder = container.Bind("foo", (c, p) => "boo");
            container.Make("foo");
            binder.Unbind();

            container.Bind("foo", (c, p) => "bar");

            Assert.AreEqual(1, count);
        }

        [TestMethod]
        public void TestReboundWithInstance()
        {
            var count = 0;
            container.Instance("foo", "foo");
            container.OnRebound("foo", (instance) =>
            {
                Assert.AreEqual("bar", instance);
                count++;
            });
            container.Instance("foo", "bar");
            Assert.AreEqual(1, count);
        }

        [TestMethod]
        public void TestUnbindNotExistsService()
        {
            container.Unbind("service not exists");
        }

        [TestMethod]
        public void TestHasInstance()
        {
            container.Instance("foo", "foo");

            Assert.IsTrue(container.HasInstance("foo"));
            Assert.IsFalse(container.HasInstance("bar"));
        }

        [TestMethod]
        public void TestIsResolved()
        {
            container.Instance("foo", "foo");

            Assert.IsTrue(container.IsResolved("foo"));
            Assert.IsFalse(container.IsResolved("bar"));

            container.Bind("bar", typeof(Bar), true);
            Assert.IsFalse(container.IsResolved("bar"));

            container.Make("bar");
            Assert.IsTrue(container.IsResolved("bar"));
        }

        [TestMethod]
        public void TestExtend()
        {
            container.Bind("foo", (container, args) => "foo", false);
            container.Extend("foo", (instance, container) => instance + "bar");

            Assert.AreEqual("foobar", container["foo"]);
        }

        [TestMethod]
        public void TestExtendMult()
        {
            container.Bind("foo", (container, args) => "foo", false);
            container.Extend("foo", (instance, container) => instance + "bar");
            container.Extend("foo", (instance, container) => instance + "baz");

            Assert.AreEqual("foobarbaz", container["foo"]);
        }

        [TestMethod]
        public void TestExtendSingle()
        {
            container.Bind("foo", (container, args) => "foo", true);
            container.Extend("foo", (instance, container) => instance + "bar");

            Assert.AreEqual("foobar", container["foo"]);

            // Existing instances are only valid if they are extended.
            container.Extend("foo", (instance, container) => instance + "baz");
            Assert.AreEqual("foobarbaz", container["foo"]);

            container.Release("foo");
            Assert.AreEqual("foobar", container["foo"]);
        }

        [TestMethod]
        public void TestExtendAndRebound()
        {
            container.Bind("foo", (container, args) => "foo", false);

            // marked resolved.
            container.Make("foo");
            container.Release("foo");

            var actual = string.Empty;
            container.OnRebound("foo", (instance) =>
            {
                actual = instance.ToString();
            });

            container.Extend("foo", (instance, container) => instance + "bar");

            Assert.AreEqual("foobar", actual);
        }

        [TestMethod]
        [ExpectedException(typeof(UnresolvableException))]
        public void TestExtendGivenMismatchedType()
        {
            var service = container.Type2Service(typeof(Foo));
            container.Bind(service, typeof(Foo), true);
            container.Bind("foobar", typeof(FooBar), true);

            container.Extend(service, (instance, container) => "mismatched type");
            container.Make("foobar");
        }

        [TestMethod]
        public void TestClearExtend()
        {
            if (!(container is CContainer catlibContainer))
            {
                return;
            }

            container.Bind("foo", (container, args) => "foo", false);
            container.Extend("foo", (instance, container) => instance + "bar");
            container.Extend("foo", (instance, container) => instance + "baz");

            container.Bind("bar", (container, args) => "bar", false);
            container.Extend("bar", (instance, container) => instance + "foo");
            container.Extend("bar", (instance, container) => instance + "baz");

            Assert.AreEqual("foobarbaz", container["foo"]);
            Assert.AreEqual("barfoobaz", container["bar"]);

            catlibContainer.ClearExtenders("foo");

            Assert.AreEqual("foo", container["foo"]);
            Assert.AreEqual("barfoobaz", container["bar"]);
        }

        [TestMethod]
        public void TestIndexer()
        {
            container["foo"] = "bar";
            Assert.AreEqual("bar", container["foo"]);
        }

        [TestMethod]
        public void TestIndexerOverride()
        {
            container["foo"] = "bar";
            Assert.AreEqual("bar", container["foo"]);

            container["foo"] = "baz";
            Assert.AreEqual("baz", container["foo"]);
        }

        [TestMethod]
        public void TestOnAfterResolving()
        {
            var step = 0;
            container.OnAfterResolving((binder, instance) =>
            {
                Assert.AreEqual(1, step);
                step = 2;
            });
            container.OnAfterResolving((binder, instance) =>
            {
                Assert.AreEqual(2, step);
                step = 3;
            });
            container.OnResolving((binder, instance) =>
            {
                Assert.AreEqual(0, step);
                step = 1;
            });

            container["foo"] = "bar";
            Assert.AreEqual("bar", container["foo"]);
            Assert.AreEqual(3, step);
        }

        [TestMethod]
        public void TestOnAfterResolvingLocal()
        {
            var step = 0;
            container.Bind("foo", (binder, instance) => "bar")
                .OnAfterResolving(() =>
            {
                Assert.AreEqual(1, step);
                step = 2;
            }).OnAfterResolving((_) =>
            {
                Assert.AreEqual(2, step);
                step = 3;
            }).OnResolving(() =>
            {
                Assert.AreEqual(0, step);
                step = 1;
            });

            Assert.AreEqual("bar", container["foo"]);
            Assert.AreEqual(3, step);
        }

        [TestMethod]
        public void TestNullRelease()
        {
            Assert.AreEqual(false, container.Release(null));
        }

        protected virtual IContainer CreateContainer()
        {
            return new CContainer();
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Container/TestsExtensionContainer.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using CatLib.Exception;
using CatLib.Tests.Fixture;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using CContainer = CatLib.Container.Container;

namespace CatLib.Tests.Container
{
    [TestClass]
    public class TestsExtensionContainer
    {
        private IContainer container;

        [TestInitialize]
        public void Initialize()
        {
            container = new CContainer();
            container.Singleton<IContainer>(() => container);
            container.Bind<IFoo, Foo>()
                .Alias<Foo>()
                .Alias("foo-alias");
        }

        [TestMethod]
        public void TestMake()
        {
            Assert.AreSame(container, container.Make<IContainer>());
            Assert.AreNotEqual(null, container.Make<Foo>("foo-alias"));

            var bar = container.Make(typeof(Bar));
            Assert.AreNotEqual(null, bar);
        }

        [TestMethod]
        public void TestInstance()
        {
            container.Instance<Bar>(new Bar());

            var bar = container.Make<Bar>();
            Assert.AreNotEqual(null, bar);
        }

        [TestMethod]
        public void TestRelease()
        {
            container.Release<IContainer>();
            Assert.IsFalse(container.HasInstance<IContainer>());
        }

        [TestMethod]
        public void TestAlias()
        {
            container.Alias<CContainer, IContainer>();
            Assert.IsTrue(container.IsAlias<CContainer>());
        }

        [TestMethod]
        public void TestReleaseWithObject()
        {
            container.Instance<string>("foo");
            container.Instance<int>(10);
            object[] data = null;
            Assert.AreEqual(true, container.Release(ref data));

            data = Array.Empty<object>();
            Assert.AreEqual(true, container.Release(ref data));

            data = new object[] { "foo", 10 };
            Assert.AreEqual(true, container.Release(ref data));
            Assert.AreEqual(true, data.Length == 0);

            data = new object[] { "foo", 10, 100 };
            Assert.AreEqual(false, container.Release(ref data));
            Assert.AreEqual(true, data.Length == 3);

            container.Instance<int>(10);
            data = new object[] { "foo", 10, 100 };
            Assert.AreEqual(false, container.Release(ref data, false));
            Assert.AreEqual(true, data.Length == 2);
            CollectionAssert.AreEqual(new object[] { "foo", 100 }, data);

            container.Instance<string>("foo");
            data = new object[] { 10, "foo", 100 };
            Assert.AreEqual(false, container.Release(ref data));
            Assert.AreEqual(true, data.Length == 2);
            CollectionAssert.AreEqual(new object[] { 10, 100 }, data);
        }

        [TestMethod]
        public void TestBindIf()
        {
            Assert.IsFalse(container.BindIf("foo-alias", (container, args) => new Foo(), true, out _));
            Assert.IsFalse(container.BindIf<IFoo, Foo>(out _));
            Assert.IsTrue(container.BindIf<Bar>(out _));
        }

        [TestMethod]
        public void TestSingletonIf()
        {
            Assert.IsFalse(container.SingletonIf("foo-alias", (container, args) => new Foo(), out _));
            Assert.IsFalse(container.SingletonIf<IFoo, Foo>(out _));
            Assert.IsTrue(container.SingletonIf<Bar>(out _));
        }

        [TestMethod]
        public void TestGetBind()
        {
            Assert.AreNotEqual(null, container.GetBind<IFoo>());
        }

        [TestMethod]
        public void TestCanMake()
        {
            Assert.IsTrue(container.CanMake<IContainer>());
            Assert.IsFalse(container.CanMake<int>());
        }

        [TestMethod]
        public void TestIsStatic()
        {
            Assert.IsTrue(container.IsStatic<IContainer>());
            Assert.IsFalse(container.IsStatic<IFoo>());
        }

        [TestMethod]
        public void TestIsAlias()
        {
            Assert.IsFalse(container.IsAlias<IFoo>());
            Assert.IsTrue(container.IsAlias<Foo>());
            Assert.IsFalse(container.IsAlias<IContainer>());
        }

        [TestMethod]
        public void TestWrap()
        {
            container = new CContainer();
            container.Singleton<IFoo, Foo>().Alias<Foo>();
            var expected = container.Make<IFoo>();
            var count = 0;

            var wrapped = container.Wrap((IFoo foo) =>
            {
                Assert.AreSame(expected, foo);
                count++;
            });
            wrapped();

            wrapped = container.Wrap((IFoo foo1, Foo foo2) =>
            {
                Assert.AreSame(expected, foo1);
                Assert.AreSame(foo1, foo2);
                count++;
            });
            wrapped();

            wrapped = container.Wrap((IFoo foo1, Foo foo2, IFoo foo3) =>
            {
                Assert.AreSame(expected, foo1);
                Assert.AreSame(foo1, foo2);
                Assert.AreSame(foo2, foo3);
                count++;
            });
            wrapped();

            wrapped = container.Wrap((IFoo foo1, IFoo foo2, IFoo foo3, Foo foo4) =>
            {
                Assert.AreSame(expected, foo1);
                Assert.AreSame(foo1, foo2);
                Assert.AreSame(foo2, foo3);
                Assert.AreSame(foo3, foo4);
                count++;
            });
            wrapped();

            Assert.AreEqual(4, count);
        }

        [TestMethod]
        public void TestCall()
        {
            container = new CContainer();
            container.Singleton<IFoo, Foo>().Alias<Foo>();
            var expected = container.Make<IFoo>();
            var count = 0;

            container.Call((IFoo foo) =>
            {
                Assert.AreSame(expected, foo);
                count++;
            });

            container.Call((IFoo foo1, Foo foo2) =>
            {
                Assert.AreSame(expected, foo1);
                Assert.AreSame(foo1, foo2);
                count++;
            });

            container.Call((IFoo foo1, Foo foo2, IFoo foo3) =>
            {
                Assert.AreSame(expected, foo1);
                Assert.AreSame(foo1, foo2);
                Assert.AreSame(foo2, foo3);
                count++;
            });

            container.Call((IFoo foo1, IFoo foo2, IFoo foo3, Foo foo4) =>
            {
                Assert.AreSame(expected, foo1);
                Assert.AreSame(foo1, foo2);
                Assert.AreSame(foo2, foo3);
                Assert.AreSame(foo3, foo4);
                count++;
            });

            Assert.AreEqual(4, count);
        }

        [TestMethod]
        public void TestOnResolving()
        {
            var count = 0;
            container.OnResolving<IFoo>((foo) =>
            {
                Assert.AreNotEqual(null, foo);
                count++;
            });

            container.OnResolving<Foo>((binder, foo) =>
            {
                Assert.AreNotEqual(null, foo);
                count++;
            });

            container.OnResolving<IContainer>((binder, foo) =>
            {
                Assert.AreNotEqual(null, foo);
                count++;
            });

            container.Make<IFoo>();

            Assert.AreEqual(2, count);
        }

        [TestMethod]
        public void TestOnAfterResolving()
        {
            var count = 0;
            container.OnAfterResolving<IFoo>((foo) =>
            {
                Assert.AreNotEqual(null, foo);
                count++;
            });

            container.OnAfterResolving<Foo>((binder, foo) =>
            {
                Assert.AreNotEqual(null, foo);
                count++;
            });

            container.OnAfterResolving<IContainer>((binder, foo) =>
            {
                Assert.AreNotEqual(null, foo);
                count++;
            });

            container.Make<IFoo>();

            Assert.AreEqual(2, count);
        }

        [TestMethod]
        public void TestOnRelease()
        {
            container.Unbind<IFoo>();
            container.Singleton<IFoo, Foo>();

            var count = 0;
            container.OnRelease<IFoo>((foo) =>
            {
                Assert.AreNotEqual(null, foo);
                count++;
            });

            container.OnRelease<Foo>((binder, foo) =>
            {
                Assert.AreNotEqual(null, foo);
                count++;
            });

            container.OnRelease<IContainer>((binder, foo) =>
            {
                Assert.AreNotEqual(null, foo);
                count++;
            });

            container.Make<IFoo>();
            Assert.AreEqual(0, count);

            container.Release<IFoo>();
            Assert.AreEqual(2, count);
        }

        [TestMethod]
        [ExpectedExceptionAndMessage(
            typeof(LogicException),
            "Function \"method-is-not-found\" not found.")]
        public void TestCallIllegal()
        {
            var foobar = FooBar.New();
            container.Call(foobar, "method-is-not-found");
        }

        [TestMethod]
        public void TestFactory()
        {
            container.Flush();
            container.Instance<IFoo>(new Foo());
            container.Instance("bar", "bar");

            var factory1 = container.Factory<IFoo>(100);
            var expected = container.Make<IFoo>();
            Assert.AreEqual(expected, factory1());

            var factory2 = container.Factory("bar", 200);
            Assert.AreEqual("bar", factory2());
        }

        [TestMethod]
        public void TestHasBind()
        {
            Assert.IsTrue(container.HasBind<IFoo>());
        }

        [TestMethod]
        public void TestWatch()
        {
            var binder = container.Singleton<string>(() => "foo");
            container.Make<string>();
            binder.Unbind();

            var actual = string.Empty;
            container.Watch<string>((instance) =>
            {
                actual = instance;
            });

            container.Singleton<string>(() => "bar");

            Assert.AreEqual("bar", actual);
        }

        [TestMethod]
        public void TestWatchInstanceOverride()
        {
            container.Singleton<string>(() => "foo");
            container.Make<string>();

            var actual1 = string.Empty;
            container.Watch<string>((instance) =>
            {
                actual1 = instance;
            });

            var actual2 = false;
            container.Watch<string>(() =>
            {
                actual2 = true;
            });

            container.Instance(
                container.Type2Service(typeof(string)),
                "bar");

            Assert.AreEqual("bar", actual1);
            Assert.IsTrue(actual2);
        }

        [TestMethod]
        public void TestReleaseWithTag()
        {
            container.Bind("foo", typeof(Foo), true)
                    .Tag("foobar");
            container.Bind("bar", typeof(Bar), true)
                    .Tag("foobar");

            var instances = container.Tagged("foobar");
            Assert.AreEqual(true, container.Release(ref instances));
        }

        [TestMethod]
        public void TestExtend()
        {
            container.Bind<string>(() => "foo");
            container.Bind<object>(() => "baz");
            container.Extend<string>((instance) => instance + "bar");

            Assert.AreEqual("foobar", container.Make<string>());
            Assert.AreEqual("bazbar", container.Make<object>());
        }

        [TestMethod]
        public void TestBindMethod()
        {
            container.BindMethod("foo", () => "foo");
            Assert.AreEqual("foo", container.Invoke("foo"));

            container.BindMethod("bar", (IContainer container)
                => container != null);
            Assert.IsTrue((bool)container.Invoke("bar"));

            container.BindMethod("echo", (string input) =>
            {
                return input;
            });
            Assert.AreEqual("foobar", container.Invoke("echo", "foobar"));
        }

        [TestMethod]
        public void TestUnbindMethodWithMethodName()
        {
            container.BindMethod("foo", () => "foo");
            container.BindMethod("bar", () => "bar");

            container.UnbindMethod("foo");

            Assert.ThrowsException<LogicException>(() =>
            {
                container.Invoke("foo");
            });

            Assert.AreEqual("bar", container.Invoke("bar"));
        }

        [TestMethod]
        [ExpectedException(typeof(LogicException))]
        public void TestBindMethodExists()
        {
            container.BindMethod("foo", () => "foo");
            container.BindMethod("foo", () => "bar");
        }

        [TestMethod]
        public void TestBindMethodStatic()
        {
            container.BindMethod<string>("echo", Foo.Echo);
            Assert.AreEqual("foo", container.Invoke("echo", "foo"));
        }

        [TestMethod]
        public void TestUnbindWithObject()
        {
            var foo1 = new Foo();
            container.BindMethod("Foo1.EchoInt", foo1);
            container.BindMethod("Foo1.EchoFloat", foo1);

            var foo2 = new Foo();
            container.BindMethod("Foo2.EchoInt", foo2);
            container.BindMethod("Foo2.EchoFloat", foo2);

            container.UnbindMethod(foo1);
            container.UnbindMethod("unknow-method");

            Assert.ThrowsException<LogicException>(() =>
            {
                container.Invoke("Foo1.EchoInt", 100);
            });

            Assert.ThrowsException<LogicException>(() =>
            {
                container.Invoke("Foo1.EchoFloat", 0.5f);
            });

            Assert.AreEqual(100, container.Invoke("Foo2.EchoInt", 100));
            Assert.AreEqual(0.5f, container.Invoke("Foo2.EchoFloat", 0.5f));
        }

        [TestMethod]
        public void TestContainerMethodContextual()
        {
            var foo = new Foo();
            container.BindMethod("Foo.EchoInt", foo).Needs("$input").Given(() => 200);
            Assert.AreEqual(100, container.Invoke("Foo.EchoInt", 100));
            Assert.AreEqual(200, container.Invoke("Foo.EchoInt"));
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/EventDispatcher/TestsEventDispatcher.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Tests.Fixture;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using System;
using Dispatcher = CatLib.EventDispatcher.EventDispatcher;

namespace CatLib.EventDispatcher.Tests
{
    [TestClass]
    public class TestsEventDispatcher
    {
        private Dispatcher eventDispatcher;

        [TestInitialize]
        public void Initialize()
        {
            eventDispatcher = new Dispatcher();
        }

        [TestMethod]
        public void TestRaise()
        {
            var expected = new TestEventArgs();
            var handler = new Mock<EventHandler>();
            eventDispatcher.AddListener("foo", handler.Object);
            eventDispatcher.Raise("foo", this, expected);
            handler.Verify((o) => o.Invoke(this, expected));
        }

        [TestMethod]
        public void TestAddListener()
        {
            var foo1 = new Mock<EventHandler>();
            var foo2 = new Mock<EventHandler>();

            eventDispatcher.AddListener("foo", foo1.Object);
            eventDispatcher.AddListener("foo", foo2.Object);

            CollectionAssert.AreEqual(
                new[]
                {
                    foo1.Object,
                    foo2.Object,
                }, eventDispatcher.GetListeners("foo"));
        }

        [TestMethod]
        public void TestHasListener()
        {
            var foo = new Mock<EventHandler>();
            var bar = new Mock<EventHandler>();

            eventDispatcher.AddListener("foo", foo.Object);
            eventDispatcher.AddListener("bar", bar.Object);

            Assert.IsTrue(eventDispatcher.HasListener("foo"));
            Assert.IsTrue(eventDispatcher.HasListener("bar"));
            Assert.IsFalse(eventDispatcher.HasListener("baz"));
        }

        [TestMethod]
        public void TestRepateAddSameListeners()
        {
            var foo = new Mock<EventHandler>();

            Assert.IsTrue(eventDispatcher.AddListener("foo", foo.Object));
            Assert.IsFalse(eventDispatcher.AddListener("foo", foo.Object));
        }

        [TestMethod]
        public void TestRemoveListeners()
        {
            var foo = new Mock<EventHandler>();
            var bar = new Mock<EventHandler>();
            var expected = new TestEventArgs();

            eventDispatcher.AddListener("foo", foo.Object);
            eventDispatcher.AddListener("bar", bar.Object);

            eventDispatcher.Raise("foo", this, expected);
            eventDispatcher.Raise("bar", this, expected);

            foo.Verify((o) => o.Invoke(this, expected));
            bar.Verify((o) => o.Invoke(this, expected));

            eventDispatcher.RemoveListener("foo", foo.Object);

            eventDispatcher.Raise("foo", this, expected);
            eventDispatcher.Raise("bar", this, expected);

            foo.Verify((o) => o.Invoke(this, expected), Times.Exactly(1));
            bar.Verify((o) => o.Invoke(this, expected), Times.Exactly(2));
        }

        [TestMethod]
        public void TestRemoveAllListeners()
        {
            var foo1 = new Mock<EventHandler>();
            var foo2 = new Mock<EventHandler>();
            var expected = new TestEventArgs();

            eventDispatcher.AddListener("foo", foo1.Object);
            eventDispatcher.AddListener("foo", foo2.Object);

            eventDispatcher.Raise("foo", this, expected);

            foo1.Verify((o) => o.Invoke(this, expected));
            foo2.Verify((o) => o.Invoke(this, expected));

            eventDispatcher.RemoveListener("foo");

            eventDispatcher.Raise("foo", this, expected);

            foo1.Verify((o) => o.Invoke(this, expected), Times.Exactly(1));
            foo2.Verify((o) => o.Invoke(this, expected), Times.Exactly(1));
        }

        [TestMethod]
        public void TestRemoveNotExistsListener()
        {
            var foo = new Mock<EventHandler>();
            Assert.IsFalse(eventDispatcher.RemoveListener("foo", foo.Object));
            Assert.IsFalse(eventDispatcher.RemoveListener("bar"));
        }

        [TestMethod]
        public void TestStoppableEvent()
        {
            var foo1 = new Mock<EventHandler>();
            var foo2 = new Mock<EventHandler>();
            var expected = new TestEventArgs();

            foo1.Setup((o) => o.Invoke(this, expected)).Callback(() =>
            {
                expected.StopPropagation();
            });

            eventDispatcher.AddListener("foo", foo1.Object);
            eventDispatcher.AddListener("foo", foo2.Object);

            eventDispatcher.Raise("foo", this, expected);

            foo1.Verify((o) => o.Invoke(this, expected));
            foo2.Verify((o) => o.Invoke(this, expected), Times.Never);
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/AbstractClass.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib.Tests.Fixture
{
    public abstract class AbstractClass
    {
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/Bar.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using System;

namespace CatLib.Tests.Fixture
{
    public sealed class Bar : IDisposable
    {
        public Bar(int? num = null)
        {
            Num = num;
        }

        [Inject(Required = false)]
        public int? Age { get; set; } = 18;

        public int? Num { get; private set; }

        public bool Disposed { get; private set; } = false;

        public override string ToString()
        {
            return "bar";
        }

        public void Dispose()
        {
            Disposed = true;
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/Baz.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace CatLib.Tests.Fixture
{
    public sealed class Baz
    {
        public Baz(Foo foo, int boo = 100)
        {
            Boo = boo;
            Assert.AreNotEqual(null, foo);
            Assert.AreNotEqual(null, boo);
        }

        [Inject(Required = false)]
        public string Name { get; set; } = "baz";

        [Inject]
        public Bar Bar { get; set; }

        [Inject]
        public int Qux { get; set; }

        public int Boo { get; private set; }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/CircularDependency.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace CatLib.Tests.Fixture
{
    public class CircularDependency
    {
        public CircularDependency(CircularDependency dependency)
        {
            Assert.AreEqual(null, dependency);

            // This is a class that causes a circular
            // dependency call to occur in DI.
        }

        public virtual object Foo(CircularDependency dependency)
        {
            return "foo";
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/Foo.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

#pragma warning disable CA1822

namespace CatLib.Tests.Fixture
{
    public class Foo : IFoo
    {
        public static string Echo(string input)
        {
            return input;
        }

        public int EchoInt(int input)
        {
            return input;
        }

        public float EchoFloat(float input)
        {
            return input;
        }

        public override string ToString()
        {
            return "foo";
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/FooBar.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

#pragma warning disable CA1822

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace CatLib.Tests.Fixture
{
    public class FooBar
    {
        public FooBar(Foo foo, Bar bar)
        {
            Assert.AreNotEqual(null, foo);
            Assert.AreNotEqual(null, bar);

            Foo = foo;
            Bar = bar;
        }

        public Foo Foo { get; private set; }

        public Bar Bar { get; private set; }

        public static FooBar New()
        {
            return new FooBar(new Foo(), new Bar());
        }

        public string GetName(Foo foo, Bar bar)
        {
            return foo.ToString() + bar.ToString();
        }

        public override string ToString()
        {
            return Foo.ToString() + Bar.ToString();
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/Fubar.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

#pragma warning disable CA2227

using CatLib.Container;
using System.Collections.Generic;

namespace CatLib.Tests.Fixture
{
    public class Fubar
    {
        public Fubar(Bar bar = null, IList<string> heros = null)
        {
            Bar = bar;
            Heros = heros;
        }

        public Bar Bar { get; private set; }

        [Inject(Required = false)]
        public Position Position { get; private set; }

        [Inject(Required = false)]
        public IList<int> Ages { get; set; }

        public IList<string> Heros { get; set; }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/FubarChild.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;
using System.Collections.Generic;

namespace CatLib.Tests.Fixture
{
    public class FubarChild : Fubar
    {
        public FubarChild(Bar bar = null, IList<string> heros = null)
            : base(bar, heros)
        {
        }

        [Inject(Required = false)]
        public Foo Foo { get; set; }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/IFoo.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib.Tests.Fixture
{
#pragma warning disable CA1040
    public interface IFoo
#pragma warning restore CA1040
    {
        // empty interface.
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/Position.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

#pragma warning disable CA1815

namespace CatLib.Tests.Fixture
{
    public struct Position
    {
        public int X { get; set; }

        public int Y { get; set; }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/Quux.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib.Tests.Fixture
{
    public class Quux
    {
        protected Quux()
        {
            // There are no constructors available for this class.
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/QuuxFoo.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib.Tests.Fixture
{
    public class QuuxFoo : Quux
    {
        public QuuxFoo()
        {
            throw new TestException(nameof(QuuxFoo));
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/TestEventArgs.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.EventDispatcher;
using System;

namespace CatLib.Tests.Fixture
{
    public class TestEventArgs : EventArgs, IStoppableEvent
    {
        public bool IsPropagationStopped { get; private set; }

        public void StopPropagation()
        {
            IsPropagationStopped = true;
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/Variant.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

namespace CatLib.Tests.Fixture
{
    public class Variant
    {
        public Variant(VariantModel model)
        {
            Model = model;
        }

        public VariantModel Model { get; private set; }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Fixture/VariantModel.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Container;

namespace CatLib.Tests.Fixture
{
    [Variant]
    public class VariantModel
    {
        public VariantModel(int id)
        {
            if (id == -1)
            {
                throw new TestException("VariantModel");
            }

            if (id == 1)
            {
                Name = "iron man";
            }
            else if (id == 2)
            {
                Name = "black window";
            }
            else
            {
                Name = "Undefiend";
            }
        }

        public string Name { get; }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Framework/ExpectedExceptionAndMessageAttribute.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using SException = System.Exception;

namespace CatLib.Tests
{
    /// <summary>
    /// Expectation exception class that allows developers to make exception content decisions.
    /// </summary>
    public class ExpectedExceptionAndMessageAttribute : ExpectedExceptionBaseAttribute
    {
        private readonly Type expectedExceptionType;
        private readonly string expectedExceptionMessage;
        private readonly bool strict;

        public ExpectedExceptionAndMessageAttribute(Type expectedExceptionType)
        {
            this.expectedExceptionType = expectedExceptionType;
            expectedExceptionMessage = string.Empty;
        }

        public ExpectedExceptionAndMessageAttribute(Type expectedExceptionType, string expectedExceptionMessage, bool strict = false)
        {
            this.expectedExceptionType = expectedExceptionType;
            this.expectedExceptionMessage = expectedExceptionMessage;
            this.strict = strict;
        }

        protected override void Verify(SException exception)
        {
            Assert.IsNotNull(exception);

            do
            {
                if (expectedExceptionType.IsAssignableFrom(exception.GetType()))
                {
                    break;
                }

                exception = exception.InnerException;
            }
            while (exception != null);

            Assert.IsInstanceOfType(exception, expectedExceptionType, "Wrong type of exception was thrown.");

            if (!expectedExceptionMessage.Length.Equals(0))
            {
                var message = exception.Message.Replace(Environment.NewLine, "\n", StringComparison.Ordinal);
                if (strict)
                {
                    Assert.AreEqual(expectedExceptionMessage, message, "Wrong exception message was returned.");
                }
                else
                {
                    if (message.IndexOf(
                        expectedExceptionMessage,
                        StringComparison.InvariantCultureIgnoreCase) < 0)
                    {
                        Assert.AreEqual(expectedExceptionMessage, message, "Wrong exception message was returned.");
                    }
                }
            }
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Framework/TestException.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using System.Runtime.Serialization;
using SException = System.Exception;

namespace CatLib.Tests
{
    public class TestException : SException
    {
        public TestException()
        {
        }

        public TestException(string message)
            : base(message)
        {
        }

        public TestException(string message, SException innerException)
            : base(message, innerException)
        {
        }

        protected TestException(SerializationInfo serializationInfo, StreamingContext streamingContext)
            : base(serializationInfo, streamingContext)
        {
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Framework/TestMethodIterativeAttribute.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;

namespace CatLib.Core.Tests.Framework
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
    public class TestMethodIterativeAttribute : TestMethodAttribute
    {
        private readonly int stabilityThreshold;

        public TestMethodIterativeAttribute(int stabilityThreshold = 1)
        {
            this.stabilityThreshold = stabilityThreshold;
        }

        public override TestResult[] Execute(ITestMethod testMethod)
        {
            var results = new List<TestResult>();
            for (int count = 0; count < stabilityThreshold; count++)
            {
                var currentResults = base.Execute(testMethod);
                results.AddRange(currentResults);
            }

            return results.ToArray();
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/IO/TestsCombineStream.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.IO;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.IO;
using System.Text;

#pragma warning disable CA1034

namespace CatLib.Tests.IO
{
    [TestClass]
    public class TestsCombineStream
    {
        private Encoding encoding;
        private Stream foo;
        private Stream bar;

        [TestInitialize]
        public void Initialize()
        {
            encoding = Encoding.UTF8;
            foo = "foo".ToStream();
            bar = "bar".ToStream();
        }

        [TestMethod]
        public void TestCombineStream()
        {
            var foobar = new CombineStream(foo, bar);
            Assert.AreEqual("foobar", foobar.ToText());
        }

        [TestMethod]
        public void TestRead()
        {
            var foobar = new CombineStream(foo, bar);

            var buffer = new byte[5];
            Assert.AreEqual(5, foobar.Read(buffer, 0, 5));
            Assert.AreEqual("fooba", encoding.GetString(buffer));

            Assert.AreEqual(1, foobar.Read(buffer, 0, 5));
            Assert.AreEqual("r", encoding.GetString(buffer, 0, 1));
        }

        [TestMethod]
        public void TestCombineSeek()
        {
            var foobar = new CombineStream(foo, bar);

            var buffer = new byte[3];
            Assert.AreEqual(3, foobar.Read(buffer, 0, 3));
            Assert.AreEqual("foo", encoding.GetString(buffer));
            Assert.AreEqual(3, foobar.Read(buffer, 0, 3));
            Assert.AreEqual("bar", encoding.GetString(buffer));

            foobar.Seek(3, SeekOrigin.Begin);
            Assert.AreEqual(3, foobar.Read(buffer, 0, 3));
            Assert.AreEqual("bar", encoding.GetString(buffer));

            foobar.Seek(2, SeekOrigin.Begin);
            Assert.AreEqual(3, foobar.Read(buffer, 0, 3));
            Assert.AreEqual("oba", encoding.GetString(buffer));

            foobar.Seek(4, SeekOrigin.Begin);
            Assert.AreEqual(2, foobar.Read(buffer, 0, 3));
            Assert.AreEqual("ar", encoding.GetString(buffer, 0, 2));

            foobar.Seek(6, SeekOrigin.Begin);
            Assert.AreEqual(0, foobar.Read(buffer, 0, 3));
            Assert.AreEqual(0, foobar.Read(buffer, 0, 3));

            foobar.Seek(-3, SeekOrigin.End);
            Assert.AreEqual(3, foobar.Read(buffer, 0, 3));
            Assert.AreEqual("bar", encoding.GetString(buffer));
        }

        [TestMethod]
        public void TestSetPosition()
        {
            var foobar = new CombineStream(foo, bar);
            var buffer = new byte[3];
            foobar.Position = 3;

            Assert.AreEqual(3, foobar.Read(buffer, 0, 3));
            Assert.AreEqual("bar", encoding.GetString(buffer));
        }

        [TestMethod]
        public void TestCanStatus()
        {
            var foobar = new CombineStream(foo, bar);

            Assert.IsFalse(foobar.CanWrite);
            Assert.IsTrue(foobar.CanSeek);
            Assert.IsTrue(foobar.CanRead);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentOutOfRangeException))]
        public void TestSeekOutOfRange()
        {
            var foobar = new CombineStream(foo, bar);
            foobar.Seek(999, SeekOrigin.Begin);
        }

        [TestMethod]
        public void TestCannotSeekStream()
        {
            var foobar = new CombineStream(foo, new CannotSeekStream());
            Assert.IsFalse(foobar.CanSeek);
        }

        [TestMethod]
        [ExpectedException(typeof(NotSupportedException))]
        public void TestCannotSeekStreamSetPosition()
        {
            var foobar = new CombineStream(foo, new CannotSeekStream());
            foobar.Seek(0, SeekOrigin.Begin);
        }

        [TestMethod]
        public void TestDispose()
        {
            Assert.IsTrue(foo.CanWrite);
            Assert.IsTrue(bar.CanWrite);

            var foobar = new CombineStream(foo, bar, true);
            foobar.Dispose();

            Assert.IsFalse(foo.CanWrite);
            Assert.IsFalse(bar.CanWrite);
        }

        [TestMethod]
        [ExpectedException(typeof(NotSupportedException))]
        public void TestWrite()
        {
            var foobar = new CombineStream(foo, bar);
            foobar.Write(new byte[5], 0, 1);
        }

        [TestMethod]
        [ExpectedException(typeof(NotSupportedException))]
        public void TestSetLength()
        {
            var foobar = new CombineStream(foo, bar);
            foobar.SetLength(10);
        }

        [TestMethod]
        [ExpectedException(typeof(NotSupportedException))]
        public void TestFlush()
        {
            var foobar = new CombineStream(foo, bar);
            foobar.Flush();
        }

        private sealed class CannotSeekStream : WrapperStream
        {
            public override bool CanSeek => false;
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/IO/TestsRingBuffer.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Exception;
using CatLib.IO;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;

namespace CatLib.Tests.IO
{
    [TestClass]
    public class TestsRingBuffer
    {
        [TestMethod]
        public void TestReadWrite()
        {
            var ringBuffer = new RingBufferStream();
            ringBuffer.Write(new byte[] { 1, 2, 4, 5 }, 1, 2);

            var read = Read(ringBuffer);
            CollectionAssert.AreEqual(
                new byte[]
            {
                2, 4,
            }, read);

            ringBuffer = new RingBufferStream();
            ringBuffer.Write(new byte[] { 1, 2, 3, 4, 5 }, 2, 3);

            var actual = new byte[5];
            var count = ringBuffer.Read(actual, 2, actual.Length - 2);

            Assert.AreEqual(3, count);
            CollectionAssert.AreEqual(
                new byte[]
            {
                0, 0, 3, 4, 5,
            }, actual);
        }

        [TestMethod]
        public void TestCanRead()
        {
            var ringBuffer = new RingBufferStream();
            var data = new byte[] { 1, 2, 3, 4, 5 };
            ringBuffer.Write(data, 0, data.Length);

            Assert.IsTrue(ringBuffer.ReadableCount >= 4);
            Assert.IsTrue(ringBuffer.ReadableCount >= 5);
            Assert.IsFalse(ringBuffer.ReadableCount >= 6);

            ringBuffer.Write(data, 0, data.Length);
            Assert.IsTrue(ringBuffer.ReadableCount >= 9);
            Assert.IsTrue(ringBuffer.ReadableCount >= 10);
            Assert.IsFalse(ringBuffer.ReadableCount >= 11);
        }

        [TestMethod]
        public void TestCanWrite()
        {
            // 16 cap
            var ringBuffer = new RingBufferStream(12);
            Assert.IsTrue(ringBuffer.WriteableCount >= 15);
            Assert.IsTrue(ringBuffer.WriteableCount >= 16);
            Assert.IsFalse(ringBuffer.WriteableCount >= 17);

            ringBuffer.Write(new byte[] { 1, 2, 3, 4, 5 }, 0, 5);
            Assert.IsTrue(ringBuffer.WriteableCount >= 10);
            Assert.IsTrue(ringBuffer.WriteableCount >= 11);
            Assert.IsFalse(ringBuffer.WriteableCount >= 12);

            ringBuffer.Write(new byte[] { 1, 2, 3, 4, 5 }, 3, 2);
            Assert.IsTrue(ringBuffer.WriteableCount >= 8);
            Assert.IsTrue(ringBuffer.WriteableCount >= 9);
            Assert.IsFalse(ringBuffer.WriteableCount >= 10);
        }

        [TestMethod]
        public void TestPeek()
        {
            // 16 cap
            var ringBuffer = new RingBufferStream(12);
            var buffer = new byte[] { 1, 2, 3, 4, 5 };
            ringBuffer.Write(buffer, 0, buffer.Length);

            Assert.AreEqual(11, ringBuffer.WriteableCount);
            Assert.AreEqual(5, ringBuffer.ReadableCount);
            CollectionAssert.AreEqual(
                new byte[]
            {
                1, 2, 3, 4, 5,
            }, Peek(ringBuffer));

            var actual = new byte[5];
            var read = ringBuffer.Peek(actual, 3, actual.Length - 3);

            Assert.AreEqual(2, read);
            CollectionAssert.AreEqual(
                new byte[]
            {
                0, 0, 0, 1, 2,
            }, actual);

            read = ringBuffer.Peek(actual, 0, actual.Length);
            Assert.AreEqual(5, read);
            CollectionAssert.AreEqual(
                new byte[]
            {
                1, 2, 3, 4, 5,
            }, actual);

            Assert.AreEqual(11, ringBuffer.WriteableCount);
            Assert.AreEqual(5, ringBuffer.ReadableCount);

            Read(ringBuffer);
            Assert.AreEqual(16, ringBuffer.WriteableCount);
            Assert.AreEqual(0, ringBuffer.ReadableCount);
        }

        [TestMethod]
        [ExpectedException(typeof(RuntimeException))]
        public void TestFullBuffer()
        {
            var ringBuffer = new RingBufferStream(4);
            ringBuffer.Write(new byte[] { 1, 2, 3, 4, 5 }, 0, 5);
        }

        [TestMethod]
        public void TestReadEmptyBuffer()
        {
            var ringBuffer = new RingBufferStream(4);

            Assert.AreEqual(0, Read(ringBuffer).Length);
            Assert.AreEqual(0, Peek(ringBuffer).Length);

            var count = ringBuffer.Read(new byte[5], 2, 3);
            Assert.AreEqual(0, count);
        }

        [TestMethod]
        public void TestOutOffset()
        {
            var ringBuffer = new RingBufferStream(4);
            var buffer = new byte[5];

            Assert.ThrowsException<ArgumentOutOfRangeException>(() =>
            {
                ringBuffer.Read(buffer, 2, 10);
            });

            Assert.ThrowsException<ArgumentOutOfRangeException>(() =>
            {
                ringBuffer.Write(buffer, 2, 10);
            });
        }

        [TestMethod]
        public void TestGetBuffer()
        {
            // 16 cap
            var ringBuffer = new RingBufferStream(12);
            Assert.AreEqual(16, ringBuffer.GetBuffer().Length);

            ringBuffer = new RingBufferStream(12, false);
            Assert.ThrowsException<UnauthorizedAccessException>(() =>
            {
                ringBuffer.GetBuffer();
            });
        }

        [TestMethod]
        public void TestBufferReuse()
        {
            // 16 cap
            var ringBuffer = new RingBufferStream(12);
            var expected = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

            ringBuffer.Write(expected, 0, expected.Length);
            Read(ringBuffer);

            ringBuffer.Write(expected, 0, expected.Length);
            var read = Read(ringBuffer);

            CollectionAssert.AreEqual(expected, read);
        }

        [TestMethod]
        public void TestCapacity()
        {
            // 32 cap
            var ringBuffer = new RingBufferStream(18);
            Assert.AreEqual(32, ringBuffer.Capacity);
        }

        [TestMethod]
        public void TestClear()
        {
            // 32 cap
            var ringBuffer = new RingBufferStream(18);
            var data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            ringBuffer.Write(data, 0, data.Length);
            ringBuffer.Clear();

            Assert.AreEqual(0, ringBuffer.ReadableCount);
            Assert.AreEqual(32, ringBuffer.WriteableCount);

            using (ringBuffer = new RingBufferStream(18))
            {
                ringBuffer.Write(data, 0, data.Length);
            }

            Assert.AreEqual(0, ringBuffer.ReadableCount);
            Assert.AreEqual(32, ringBuffer.WriteableCount);
        }

        private static byte[] Read(RingBufferStream stream)
        {
            var buffer = new byte[stream.Length - stream.Position];
            stream.Read(buffer, 0, buffer.Length);
            return buffer;
        }

        private static byte[] Peek(RingBufferStream stream)
        {
            var buffer = new byte[stream.Length - stream.Position];
            stream.Peek(buffer, 0, buffer.Length);
            return buffer;
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/IO/TestsSegmentStream.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.IO;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.IO;
using System.Text;

namespace CatLib.Tests.IO
{
    [TestClass]
    public class TestsSegmentStream
    {
        private Encoding encoding;
        private Stream foobarbaz;

        [TestInitialize]
        public void Initialize()
        {
            encoding = Encoding.UTF8;
            foobarbaz = "foo bar baz".ToStream();
        }

        [TestMethod]
        public void TestRead()
        {
            var segment = new SegmentStream(foobarbaz, 3);
            Assert.AreEqual("foo", segment.ToText());
        }

        [TestMethod]
        public void TestReadMiddle()
        {
            foobarbaz.Seek(4, SeekOrigin.Begin);
            var segment = new SegmentStream(foobarbaz, 3);
            Assert.AreEqual("bar", segment.ToText());
        }

        [TestMethod]
        public void TestReadEnd()
        {
            foobarbaz.Seek(4, SeekOrigin.Begin);
            var segment = new SegmentStream(foobarbaz);
            Assert.AreEqual("bar baz", segment.ToText());
        }

        [TestMethod]
        public void TestSeekEnd()
        {
            var segment = new SegmentStream(foobarbaz, 7);
            segment.Seek(-3, SeekOrigin.End);
            Assert.AreEqual("bar", segment.ToText());
        }

        [TestMethod]
        public void TestSeekCurrent()
        {
            foobarbaz.Seek(2, SeekOrigin.Begin);
            var segment = new SegmentStream(foobarbaz, 5);
            segment.Seek(2, SeekOrigin.Current);
            Assert.AreEqual("bar", segment.ToText());
        }

        [TestMethod]
        public void TestSeekBegin()
        {
            var segment = new SegmentStream(foobarbaz, 7);
            segment.ToText(null, false);

            segment.Seek(0, SeekOrigin.Begin);
            Assert.AreEqual("foo bar", segment.ToText());
        }

        [TestMethod]
        public void TestGetLength()
        {
            var segmentStream = new SegmentStream(foobarbaz, 7);
            Assert.AreEqual(7, segmentStream.Length);
        }

        [TestMethod]
        public void TestGetPosition()
        {
            foobarbaz.Seek(2, SeekOrigin.Begin);
            var segment = new SegmentStream(foobarbaz, 5)
            {
                Position = 4,
            };

            Assert.AreEqual(4, segment.Position);
        }

        [TestMethod]
        public void TestReadBuffer()
        {
            var segment = new SegmentStream(foobarbaz, 7);
            var actual = new byte[255];
            Assert.AreEqual(7, segment.Read(actual, 0, 255));
            Assert.AreEqual("foo bar", encoding.GetString(actual, 0, 7));
        }

        [TestMethod]
        public void TestReadBufferEnd()
        {
            var segment = new SegmentStream(foobarbaz, 7);
            var actual = new byte[255];
            Assert.AreEqual(7, segment.Read(actual, 0, 255));
            Assert.AreEqual("foo bar", encoding.GetString(actual, 0, 7));
            Assert.AreEqual(0, segment.Read(actual, 0, 255));
        }

        [TestMethod]
        public void TestReadBufferMin()
        {
            var segment = new SegmentStream(foobarbaz, 7);
            var buffer = new byte[3];
            Assert.AreEqual(3, segment.Read(buffer, 0, 3));
            Assert.AreEqual("foo", encoding.GetString(buffer));
        }

        [TestMethod]
        [ExpectedException(typeof(NotSupportedException))]
        public void TestSetLength()
        {
            var segment = new SegmentStream(foobarbaz);
            segment.SetLength(100);
        }

        [TestMethod]
        [ExpectedException(typeof(NotSupportedException))]
        public void TestWrite()
        {
            var segment = new SegmentStream(foobarbaz);
            var data = encoding.GetBytes("foo");
            segment.Write(data, 0, data.Length);
        }

        [TestMethod]
        public void TestSeekEndToRead()
        {
            var segment = new SegmentStream(foobarbaz);
            segment.Seek(999, SeekOrigin.End);
            Assert.AreEqual(string.Empty, segment.ToText());
        }

        [TestMethod]
        public void TestSeekSmallThenStart()
        {
            var segment = new SegmentStream(foobarbaz);
            segment.Seek(-999, SeekOrigin.Begin);
            Assert.AreEqual("foo bar baz", segment.ToText());
        }

        [TestMethod]
        [ExpectedException(typeof(InvalidOperationException))]
        public void TestGivenCanNotSeek()
        {
            new SegmentStream(new CanNotSeekStream());
        }

        private class CanNotSeekStream : WrapperStream
        {
            public override bool CanSeek => false;
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/IO/TestsStreamExtension.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.IO;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.IO;
using System.Text;

namespace CatLib.Tests.IO
{
    [TestClass]
    public class TestsStreamExtension
    {
        [TestMethod]
        public void TestAppendTo()
        {
            var stream1 = "foo".ToStream();
            var stream2 = new MemoryStream();

            Assert.AreEqual(3, stream1.AppendTo(stream2));
            Assert.AreEqual("foo", stream2.ToText());
        }

        [TestMethod]
        public void TestStreamToText()
        {
            var stream = "foo".ToStream();
            Assert.AreEqual("foo", stream.ToText());
        }

        [TestMethod]
        public void TestStreamToTextLarage()
        {
            var stream = new MemoryStream();
            var builder = new StringBuilder();

            var buffer = new byte[4096];
            for (var i = 0; i < (buffer.Length / 10) + 1; i++)
            {
                stream.Write(Encoding.Default.GetBytes("1234567890"), 0, 10);
                builder.Append("1234567890");
            }

            stream.Seek(0, SeekOrigin.Begin);
            Assert.AreEqual(builder.ToString(), stream.ToText());
        }

        [TestMethod]
        public void TestDoubleWidthText()
        {
            var stream = new MemoryStream();
            var builder = new StringBuilder();

            var buffer = new byte[4096];
            for (var i = 0; i < (buffer.Length / 10) + 1; i++)
            {
                var data = Encoding.UTF8.GetBytes("12双宽度34测试567890");
                stream.Write(data, 0, data.Length);
                builder.Append("12双宽度34测试567890");
            }

            stream.Seek(0, SeekOrigin.Begin);
            Assert.AreEqual(builder.ToString(), stream.ToText());
        }

        [TestMethod]
        public void TestStreamToTextEmpty()
        {
            var stream = new MemoryStream(0);
            Assert.AreEqual(string.Empty, stream.ToText());
        }

        [TestMethod]
        public void TestStreamClosed()
        {
            var stream = new MemoryStream(0);

            Assert.AreEqual(string.Empty, stream.ToText(null, false));
            Assert.AreEqual(true, stream.CanWrite);
            Assert.AreEqual(string.Empty, stream.ToText());
            Assert.AreEqual(false, stream.CanWrite);
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Util/TestsArr.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Util;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;

#pragma warning disable CA1031

namespace CatLib.Tests.Util
{
    [TestClass]
    public sealed class TestsArr
    {
        private string[] foo;
        private string[] bar;
        private string[] foobar;
        private string[] foobarbar;
        private string[] aux;

        [TestInitialize]
        public void Initialize()
        {
            foo = new[] { "foo" };
            bar = new[] { "bar", "baz" };
            foobar = new[] { "foo", "bar", "baz" };
            foobarbar = new[] { "foo", "bar", "baz", "bar", "baz" };
            aux = null;
        }

        [TestMethod]
        public void TestMerge()
        {
            var actual = Arr.Merge(foo, bar);

            CollectionAssert.AreEqual(foobar, actual);
        }

        [TestMethod]
        public void TestMergeAllEmpty()
        {
            var actual = Arr.Merge(Array.Empty<int>(), Array.Empty<int>());
            Assert.AreEqual(0, actual.Length);
        }

        [TestMethod]
        public void TestMergeNull()
        {
            var actual = Arr.Merge(foo, aux, bar);

            CollectionAssert.AreEqual(foobar, actual);
        }

        [TestMethod]
        public void TestMergeEmpty()
        {
            var actual = Arr.Merge(foo, Array.Empty<string>(), bar);

            CollectionAssert.AreEqual(foobar, actual);
        }

        [TestMethod]
        public void TestRandom()
        {
            var source = new[] { "foo", "bar", "baz", "aux" };
            var actual = Arr.Rand(source);

            var i = 0;
            while (Arr.Rand(source)[0] == actual[0])
            {
                if (i++ > 1000)
                {
                    Assert.Fail("Random look's not work.");
                }
            }

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz", "aux",
            }, source);
        }

        [TestMethod]
        public void TestSplice()
        {
            var removed = Arr.Splice(ref foobar, 1, 1, bar);

            Assert.AreEqual("bar", removed[0]);
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz", "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestBaseNegativeSplice()
        {
            var removed = Arr.Splice(ref foobar, -1, null, bar);

            Assert.AreEqual("baz", removed[0]);
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "bar", "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestSimpleArgsSplice()
        {
            var removed = Arr.Splice(ref foobar, 1);

            CollectionAssert.AreEqual(
                new[]
            {
                "bar", "baz",
            }, removed);
            CollectionAssert.AreEqual(new[] { "foo" }, foobar);
        }

        [TestMethod]
        public void TestSimpleNegativeStart()
        {
            var removed = Arr.Splice(ref foobar, -1);

            CollectionAssert.AreEqual(new[] { "baz" }, removed);
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar",
            }, foobar);
        }

        [TestMethod]
        public void TestZeroStart()
        {
            var removed = Arr.Splice(ref foobar, 0);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz",
            }, removed);

            CollectionAssert.AreEqual(Array.Empty<string>(), foobar);
        }

        [TestMethod]
        public void TestOverflowNegativeStart()
        {
            var removed = Arr.Splice(ref foobar, -999);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz",
            }, removed);

            CollectionAssert.AreEqual(Array.Empty<string>(), foobar);
        }

        [TestMethod]
        public void TestOverflowStart()
        {
            var removed = Arr.Splice(ref foobar, 999);

            CollectionAssert.AreEqual(Array.Empty<string>(), removed);
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestOverflowStartRepl()
        {
            var removed = Arr.Splice(ref foobar, 999, -999, bar);

            CollectionAssert.AreEqual(Array.Empty<string>(), removed);
            CollectionAssert.AreEqual(foobarbar, foobar);
        }

        [TestMethod]
        public void TestChunk()
        {
            var actual = Arr.Chunk(foobarbar, 2);

            CollectionAssert.AreEqual(new[] { "foo", "bar" }, actual[0]);
            CollectionAssert.AreEqual(new[] { "baz", "bar" }, actual[1]);
            CollectionAssert.AreEqual(new[] { "baz" }, actual[2]);
        }

        [TestMethod]
        public void TestChunkInsufficientQuantity()
        {
            var source = new[] { "foo" };
            var actual = Arr.Chunk(source, 2);

            CollectionAssert.AreEqual(new[] { "foo" }, actual[0]);
        }

        [TestMethod]
        public void TestChunkBound()
        {
            var actual = Arr.Chunk(foobar, 2);
            CollectionAssert.AreEqual(new[] { "foo", "bar" }, actual[0]);
            CollectionAssert.AreEqual(new[] { "baz" }, actual[1]);
        }

        [TestMethod]
        public void TestFill()
        {
            var actual = Arr.Fill(1, 5, "foo");

            CollectionAssert.AreEqual(
                new[]
            {
                null, "foo", "foo", "foo", "foo", "foo",
            }, actual);
        }

        [TestMethod]
        public void TestFillZeroStart()
        {
            var actual = Arr.Fill(0, 5, "foo");
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "foo", "foo", "foo", "foo",
            }, actual);
        }

        [TestMethod]
        public void TestFillWithSource()
        {
            var actual = Arr.Fill(2, 3, "foo", foobar);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "foo", "foo", "foo", "baz",
            }, actual);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestFillBoundWithSource()
        {
            var actual = Arr.Fill(3, 3, "foo", foobar);
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz", "foo", "foo", "foo",
            }, actual);
        }

        [TestMethod]
        public void TestFillOutOfRangeWithSource()
        {
            var actual = Arr.Fill(4, 2, "foo", foobar);
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz", null, "foo", "foo",
            }, actual);
        }

        [TestMethod]
        public void TestFillZeroWithSource()
        {
            var actual = Arr.Fill(0, 3, "foo", foobar);
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "foo", "foo", "foo", "bar", "baz",
            }, actual);
        }

        [TestMethod]
        public void TestFillThrowException()
        {
            Assert.ThrowsException<ArgumentOutOfRangeException>(() =>
            {
                Arr.Fill(-1, 3, "foo");
            });

            Assert.ThrowsException<ArgumentOutOfRangeException>(() =>
            {
                Arr.Fill(0, 0, "foo");
            });
        }

        [TestMethod]
        public void TestFilter()
        {
            var actual = Arr.Filter(foobar, (f) => f == "foo");

            CollectionAssert.AreEqual(foo, actual);
        }

        [TestMethod]
        public void TestFilterExpected()
        {
            var actual = Arr.Filter(foobar, (f) => f == "foo", false);

            CollectionAssert.AreEqual(bar, actual);
        }

        [TestMethod]
        public void TestFilterIEnumerable()
        {
            var actual = Arr.Filter(
                new List<string>(foobar),
                (f) => f == "foo");

            CollectionAssert.AreEqual(foo, actual);
        }

        [TestMethod]
        public void TestMap()
        {
            var actual = Arr.Map(foobar, (o) => o + o);

            CollectionAssert.AreEqual(
                new[]
            {
                "foofoo", "barbar", "bazbaz",
            }, actual);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestMapIEnumerable()
        {
            var data = new List<string>(foobar);
            var actual = Arr.Map(data, (o) => o + o);

            CollectionAssert.AreEqual(
                new[]
            {
                "foofoo", "barbar", "bazbaz",
            }, actual);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz",
            }, data);
        }

        [TestMethod]
        public void TestPop()
        {
            var actual = Arr.Pop(ref foobar);

            Assert.AreEqual("baz", actual);
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar",
            }, foobar);
        }

        [TestMethod]
        public void TestPush()
        {
            var actual = Arr.Push(ref foobar, "aux", "foobar");
            Assert.AreEqual(5, actual);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz", "aux", "foobar",
            }, foobar);
        }

        [TestMethod]
        public void TestReduce()
        {
            var actual = Arr.Reduce(foobar, (left, right) => $"{left}-{right}", "heros");

            Assert.AreEqual("heros-foo-bar-baz", actual);
        }

        [TestMethod]
        public void TestSlice()
        {
            var actual = Arr.Slice(foobar, 1, -1);

            CollectionAssert.AreEqual(
                new[]
            {
                "bar",
            }, actual);
        }

        [TestMethod]
        public void TestShift()
        {
            var actual = Arr.Shift(ref foobar);

            Assert.AreEqual("foo", actual);
            CollectionAssert.AreEqual(
                new[]
            {
                "bar", "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestUnShift()
        {
            var actual = Arr.Unshift(ref foobar, "aux", "foobar");

            Assert.AreEqual(5, actual);
            CollectionAssert.AreEqual(
                new[]
            {
                "aux", "foobar", "foo", "bar", "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestReverse()
        {
            var actual = Arr.Reverse(foobar);

            CollectionAssert.AreEqual(
                new[]
            {
                "baz", "bar", "foo",
            }, actual);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestReverseWithStartLength()
        {
            var actual = Arr.Reverse(foobarbar, 1, 2);

            CollectionAssert.AreEqual(
                new[]
            {
                "baz", "bar",
            }, actual);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz", "bar", "baz",
            }, foobarbar);
        }

        [TestMethod]
        public void TestIndexOf()
        {
            var actual = Arr.IndexOf(foobar, new[] { "bar", "baz" });

            Assert.AreEqual(1, actual);
        }

        [TestMethod]
        public void TestIndexOfNull()
        {
            Assert.AreEqual(-1, Arr.IndexOf(null, new[] { "foo" }));
        }

        [TestMethod]
        public void TestIndexNotFind()
        {
            var actual = Arr.IndexOf(foobar, new[] { "baz", "bar" });

            Assert.AreEqual(-1, actual);
        }

        [TestMethod]
        public void TestIndexOfAny()
        {
            var actual = Arr.IndexOfAny(foobar, new[] { "baz", "bar" });

            Assert.AreEqual(1, actual);
        }

        [TestMethod]
        public void TestIndexAnyNotFind()
        {
            var actual = Arr.IndexOfAny(foobar, new[] { "auz" });

            Assert.AreEqual(-1, actual);
        }

        [TestMethod]
        public void TestIndexOfAnyNull()
        {
            var actual = Arr.IndexOfAny(foobar, null);
            Assert.AreEqual(-1, actual);

            actual = Arr.IndexOfAny<string>(null, null);
            Assert.AreEqual(-1, actual);
        }

        [TestMethod]
        public void TestDifference()
        {
            var actual = Arr.Difference(foobar, new[] { "bar", "baz" });

            CollectionAssert.AreEqual(
                new[]
            {
                "foo",
            }, actual);
        }

        [TestMethod]
        public void TestDifferenceEmptyMatch()
        {
            var actual = Arr.Difference(foobar, null);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz",
            }, actual);
        }

        [TestMethod]
        public void TestRemoveAt()
        {
            var actual = Arr.RemoveAt(ref foobar, 1);

            Assert.AreEqual("bar", actual);
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestRemoveAtWithDefault()
        {
            Assert.AreEqual("foo", Arr.RemoveAt(ref foobar, 999, "foo"));
        }

        [TestMethod]
        public void TestRemoveAtNegativeNumber()
        {
            var actual = Arr.RemoveAt(ref foobar, -2);

            Assert.AreEqual("bar", actual);
            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "baz",
            }, foobar);

            actual = Arr.RemoveAt(ref foobar, -999);

            Assert.AreEqual("foo", actual);
            CollectionAssert.AreEqual(
                new[]
            {
                "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestCut()
        {
            Arr.Cut(ref foobar, 1);
            CollectionAssert.AreEqual(
                new[]
            {
                "bar", "baz",
            }, foobar);

            Arr.Cut(ref foobar, -1);
            CollectionAssert.AreEqual(
                new[]
            {
                "bar",
            }, foobar);

            Arr.Cut(ref foobar, 0);
            CollectionAssert.AreEqual(
                new[]
            {
                "bar",
            }, foobar);

            Arr.Cut(ref foobar, 999);
            CollectionAssert.AreEqual(Array.Empty<string>(), foobar);

            Arr.Cut(ref bar, -999);
            CollectionAssert.AreEqual(Array.Empty<string>(), bar);
        }

        [TestMethod]
        public void TestRemove()
        {
            var actual = Arr.Remove(ref foobar, (o) => o == "bar");

            CollectionAssert.AreEqual(
                new[]
            {
                "bar",
            }, actual);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "baz",
            }, foobar);

            actual = Arr.Remove(ref foobarbar, (o) => o == "bar");

            CollectionAssert.AreEqual(
                new[]
            {
                "bar", "bar",
            }, actual);

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "baz", "baz",
            }, foobarbar);
        }

        [TestMethod]
        public void TestTest()
        {
            Assert.AreEqual(true, Arr.Test(foobar, (o) => o == "foo"));
        }

        [TestMethod]
        public void TestTestOutMatch()
        {
            Assert.AreEqual(true, Arr.Test(foobar, (o) => o == "bar", out string match));
            Assert.AreEqual("bar", match);
        }

        [TestMethod]
        public void TestSetReplace()
        {
            Arr.Set(ref foobar, (o) => o == "bar", "aux");

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "aux", "baz",
            }, foobar);
        }

        [TestMethod]
        public void TestSetPush()
        {
            Arr.Set(ref foobar, (o) => o == "not-found", "aux");

            CollectionAssert.AreEqual(
                new[]
            {
                "foo", "bar", "baz", "aux",
            }, foobar);
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Util/TestsGuard.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

#pragma warning disable CA1031

using CatLib.Util;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using SException = System.Exception;

namespace CatLib.Tests.Util
{
    [TestClass]
    public class TestsGuard
    {
        [TestMethod]
        public void TestRequires()
        {
            var innerException = new SException("inner exception");

            try
            {
                Guard.Requires<SException>(false, "foo", innerException);
                Assert.Fail();
            }
            catch (SException ex)
            {
                Assert.AreEqual("foo", ex.Message);
                Assert.AreEqual("inner exception", ex.InnerException.Message);
            }
        }

        [TestMethod]
        public void TestExtend()
        {
            var innerException = new SException("inner exception");

            Guard.Extend<ArgumentNullException>((messgae, inner, state) =>
            {
                return new ArgumentNullException("foo", inner);
            });

            try
            {
                Guard.Requires<ArgumentNullException>(false, null, innerException);
                Assert.Fail();
            }
            catch (SException ex)
            {
                Assert.AreEqual("foo", ex.Message);
                Assert.AreEqual("inner exception", ex.InnerException.Message);
            }
        }

        [TestMethod]
        public void TestRequireNotBaseException()
        {
            var innerException = new SException("inner exception");

            try
            {
                Guard.Requires<ArgumentNullException>(false, "foo", innerException);
                Assert.Fail();
            }
            catch (SException ex)
            {
                Assert.AreEqual("foo", ex.Message);
                Assert.AreEqual("inner exception", ex.InnerException.Message);
            }
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Util/TestsSortSet.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Core.Tests.Framework;
using CatLib.Util;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;

namespace CatLib.Tests.Util
{
    [TestClass]
    public class TestsSortSet
    {
        private SortSet<int, int> sortset;

        [TestInitialize]
        public void Init()
        {
            sortset = new SortSet<int, int>();
        }

        [TestMethod]
        public void TestRandValue()
        {
            var random = new Random();

            for (var i = 1000; i >= 1; i--)
            {
                sortset.Add(i, random.Next(0, 1000));
            }

            for (var i = 1; i <= 1000; i++)
            {
                Assert.IsTrue(sortset.Remove(i), $"can not remove index: {i}.");
            }

            Assert.AreEqual(0, sortset.Count);
        }

        [TestMethodIterative(100)]
        public void TestGetElementByRank()
        {
            sortset.Add(1000, 85);
            sortset.Add(999, 75);
            sortset.Add(998, 185);
            sortset.Add(997, 85);
            sortset.Add(996, 185);
            sortset.Add(995, 85);

            Assert.AreEqual(1, sortset.GetRank(995));
            Assert.AreEqual(995, sortset.GetElementByRank(1));
            Assert.AreEqual(997, sortset.GetElementByRank(2));
            Assert.AreEqual(1000, sortset.GetElementByRank(3));
            Assert.AreEqual(996, sortset.GetElementByRank(4));
            Assert.AreEqual(998, sortset.GetElementByRank(5));
        }

        [TestMethod]
        public void TestCustomComparer()
        {
            var foo = new SortSet<object, int>(new PriorityComparer());
            for (var i = 0; i < 10; i++)
            {
                foo.Add(i, i);
            }

            for (var i = 9; i >= 0; i--)
            {
                Assert.AreEqual(i, foo.Shift());
            }

            foo = new SortSet<object, int>();
            for (var i = 0; i < 10; i++)
            {
                foo.Add(i, i);
            }

            for (var i = 0; i < 10; i++)
            {
                Assert.AreEqual(i, foo.Shift());
            }
        }

        [TestMethod]
        public void TestAddObject()
        {
            var foo = new SortSet<object, int>();
            var collection = new List<object>();

            for (var i = 0; i < 10; i++)
            {
                var obj = new object();
                collection.Add(obj);
                foo.Add(obj, i);
            }

            CollectionAssert.AreEqual(collection, foo.ToArray());
        }

        [TestMethod]
        public void TestGetElementRangeByRank()
        {
            for (var i = 0; i < 10; i++)
            {
                sortset.Add(i, i);
            }

            var foos = sortset.GetElementRangeByRank(3, 8);
            var n = 3;
            foreach (var foo in foos)
            {
                Assert.AreEqual(n++, foo);
            }
        }

        [TestMethod]
        public void TestGetElementRangeWithOutOfRange()
        {
            Assert.AreEqual(0, sortset.GetElementRangeByRank(3, 8).Length);
        }

        [TestMethod]
        public void TestGetElementRangeByScore()
        {
            for (var i = 0; i < 10; i++)
            {
                sortset.Add(i, i);
            }

            var foos = sortset.GetElementRangeByScore(3, 8);
            var n = 3;
            foreach (var foo in foos)
            {
                Assert.AreEqual(n++, foo);
            }
        }

        [TestMethod]
        public void TestGetElementRangeByScoreOutOfRange()
        {
            Assert.AreEqual(0, sortset.GetElementRangeByScore(3, 8).Length);
        }

        [TestMethodIterative(100)]
        public void TestRemoveRangeByScore()
        {
            for (var n = 0; n < 10; n++)
            {
                sortset.Add(n, n);
            }

            sortset.RemoveRangeByScore(3, 8);
            Assert.AreEqual(0, sortset.GetElementByRank(0));
            Assert.AreEqual(1, sortset.GetElementByRank(1));
            Assert.AreEqual(2, sortset.GetElementByRank(2));
            Assert.AreEqual(9, sortset.GetElementByRank(3));
            for (var n = 3; n < 9; n++)
            {
                sortset.Add(n, n);
            }

            sortset.Add(33, 3);
            sortset.RemoveRangeByScore(3, 3);
            Assert.AreEqual(0, sortset.GetElementByRank(0));
            Assert.AreEqual(1, sortset.GetElementByRank(1));
            Assert.AreEqual(2, sortset.GetElementByRank(2));
            Assert.AreEqual(4, sortset.GetElementByRank(3));
        }

        [TestMethodIterative(100)]
        public void TestGetElementByRevRank()
        {
            for (var i = 0; i < 10; i++)
            {
                sortset.Add(i, i);
            }

            Assert.AreEqual(6, sortset.GetElementByRevRank(3));
            Assert.AreEqual(9, sortset.GetElementByRevRank(0));
            Assert.AreEqual(0, sortset.GetElementByRevRank(9));
        }

        [TestMethod]
        public void TestReversEnumerator()
        {
            int count = 50000;
            for (int i = 0; i < count; i++)
            {
                sortset.Add(i, i);
            }

            int n = 0;
            foreach (var i in sortset.GetIterator(false))
            {
                Assert.AreEqual(count - (++n), i);
            }
        }

        [TestMethod]
        public void TestScoreRangeCountBound()
        {
            sortset.Add(6, 6);
            Assert.AreEqual(1, sortset.GetRangeCount(0, 100));
            Assert.AreEqual(0, sortset.GetRangeCount(7, 100));
            Assert.AreEqual(0, sortset.GetRangeCount(0, 5));
            Assert.AreEqual(1, sortset.GetRangeCount(6, 100));

            Assert.ThrowsException<ArgumentOutOfRangeException>(() =>
            {
                Assert.AreEqual(0, sortset.GetRangeCount(800, 100));
            });
        }

        [TestMethod]
        public void TestGetRangeCountWithOutOfRange()
        {
            Assert.AreEqual(0, sortset.GetRangeCount(0, 100));
        }

        [TestMethod]
        public void TestScoreRangeCount()
        {
            var rand = new Random();
            var expected = new List<int>();
            int count = 50000;

            for (var i = 0; i < count; i++)
            {
                var score = rand.Next(0, 1000);
                sortset.Add(i, score);

                if (score <= 100)
                {
                    expected.Add(i);
                }
            }

            Assert.AreEqual(expected.Count, sortset.GetRangeCount(0, 100));
        }

        [TestMethod]
        public void TestAdd()
        {
            int count = 50000;
            var rand = new Random();

            for (var i = 0; i < count; i++)
            {
                var value = rand.Next();
                sortset.Add(value, value);
            }

            var max = 0;
            foreach (var value in sortset)
            {
                if (max <= value)
                {
                    max = value;
                }
                else
                {
                    Assert.Fail("Element sorting is incorrect.");
                }
            }
        }

        [TestMethod]
        public void TestRemove()
        {
            int count = 50000;
            var collection = new List<int>();
            var rand = new Random();

            for (var i = 0; i < count; i++)
            {
                var value = rand.Next();
                collection.Add(value);
                sortset.Add(value, value);
            }

            foreach (int value in collection)
            {
                sortset.Remove(value);
            }

            Assert.AreEqual(0, sortset.Count);
        }

        [TestMethod]
        public void TestGetElementByRankAndIndexer()
        {
            var count = 50000;
            for (var i = 0; i < count; i++)
            {
                sortset.Add(i, i);
            }

            var rand = new Random();
            for (var i = 0; i < Math.Min(count, 100); i++)
            {
                var expected = rand.Next(0, count);
                Assert.AreEqual(expected, sortset.GetElementByRank(expected));
                Assert.AreEqual(expected, sortset[expected]);
            }
        }

        [TestMethod]
        public void TestGetRevRank()
        {
            for (int i = 0; i < 10; i++)
            {
                sortset.Add(i, i);
            }

            Assert.AreEqual(6, sortset.GetRevRank(3));
        }

        [TestMethodIterative(100)]
        public void TestGetRank()
        {
            var count = 100;
            var collection = new List<int>();
            var rand = new Random();

            for (var i = 0; i < count; i++)
            {
                if (rand.NextDouble() < 0.1)
                {
                    collection.Add(i);
                }

                sortset.Add(i, i);
            }

            foreach (var expected in collection)
            {
                Assert.AreEqual(expected, sortset.GetRank(expected));
            }

            Assert.AreEqual(-1, sortset.GetRank(-1));
        }

        [TestMethod]
        public void TestSequentialAdd()
        {
            for (var i = 0; i < 50000; i++)
            {
                sortset.Add(i, i);
            }

            var expected = 0;
            foreach (var i in sortset)
            {
                Assert.AreEqual(expected++, i);
            }
        }

        [TestMethod]
        public void TestEmptyListForeach()
        {
            foreach (var item in sortset)
            {
                Assert.Fail("Iteration is not allowed.");
            }

            foreach (var item in sortset.GetIterator(false))
            {
                Assert.Fail("Iteration is not allowed.");
            }
        }

        [TestMethod]
        public void TestOverrideElement()
        {
            sortset.Add(10, 100);
            sortset.Add(10, 200);
            Assert.AreEqual(200, sortset.GetScore(10));
        }

        [TestMethod]
        public void TestContains()
        {
            sortset.Add(10, 100);

            Assert.IsTrue(sortset.Contains(10));
            Assert.IsFalse(sortset.Contains(11));
        }

        [TestMethod]
        public void TestGetScore()
        {
            sortset.Add(10, 100);
            Assert.AreEqual(100, sortset.GetScore(10));
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentOutOfRangeException))]
        public void TestGetElementByRankOverflow()
        {
            sortset.Add(10, 10);
            sortset.GetElementByRank(1000);
        }

        [TestMethod]
        [ExpectedException(typeof(InvalidOperationException))]
        public void TestGetElementByRankEmpty()
        {
            sortset.GetElementByRank(100);
        }

        [TestMethod]
        public void TestGetRankOverflow()
        {
            sortset.Add(10, 100);
            Assert.AreEqual(-1, sortset.GetRank(100));
        }

        [TestMethod]
        public void TestGetRevRankOverflow()
        {
            sortset.Add(10, 100);

            Assert.AreEqual(-1, sortset.GetRevRank(100));
            Assert.AreEqual(0, sortset.GetRevRank(10));
        }

        [TestMethod]
        public void TestMaxLevelLimit()
        {
            sortset = new SortSet<int, int>(0.5, 3);
            for (var i = 0; i < 2048; i++)
            {
                sortset.Add(i, i);
            }
        }

        [TestMethod]
        public void TestClear()
        {
            for (var i = 0; i < 65536; i++)
            {
                sortset.Add(i, i);
            }

            sortset.Clear();
            for (var i = 0; i < 65536; i++)
            {
                sortset.Add(i, i);
            }

            for (var i = 0; i < 65536; i++)
            {
                Assert.AreEqual(i, sortset.GetRank(i));
            }

            Assert.AreEqual(65536, sortset.Count);
        }

        [TestMethod]
        public void TestFirstLast()
        {
            for (var i = 0; i < 65536; i++)
            {
                sortset.Add(i, i);
            }

            Assert.AreEqual(0, sortset.First());
            Assert.AreEqual(65535, sortset.Last());

            for (var i = 0; i < 65536; i++)
            {
                Assert.AreEqual(i, sortset.First());
                Assert.AreEqual(i, sortset.Shift());
            }

            Assert.AreEqual(0, sortset.Count);

            sortset.Clear();
            for (var i = 0; i < 65536; i++)
            {
                sortset.Add(i, i);
            }

            for (var i = 0; i < 65536; i++)
            {
                Assert.AreEqual(65535 - i, sortset.Last());
                Assert.AreEqual(65535 - i, sortset.Pop());
            }
        }

        [TestMethod]
        public void TestPop()
        {
            for (var i = 0; i < 65536; i++)
            {
                sortset.Add(i, i);
            }

            for (var i = 0; i < 65536; i++)
            {
                Assert.AreEqual(65535 - i, sortset.Pop());
            }

            Assert.AreEqual(0, sortset.Count);
        }

        [TestMethod]
        public void TestShift()
        {
            for (var i = 0; i < 65536; i++)
            {
                sortset.Add(i, i);
            }

            for (var i = 0; i < 65536; i++)
            {
                Assert.AreEqual(i, sortset.Shift());
            }

            Assert.AreEqual(0, sortset.Count);
        }

        [TestMethod]
        [ExpectedException(typeof(InvalidOperationException))]
        public void TestFirstBound()
        {
            sortset.First();
        }

        [TestMethod]
        [ExpectedException(typeof(InvalidOperationException))]
        public void TestLastBound()
        {
            sortset.Last();
        }

        [TestMethod]
        public void TestToArray()
        {
            sortset.Add(1, 1);
            sortset.Add(9, 9);
            sortset.Add(2, 2);
            sortset.Add(8, 8);
            sortset.Add(0, 0);
            sortset.Add(4, 4);
            sortset.Add(5, 5);
            sortset.Add(6, 6);
            sortset.Add(3, 3);
            sortset.Add(7, 7);

            var expected = 0;
            foreach (var actual in sortset.ToArray())
            {
                Assert.AreEqual(expected++, actual);
            }
        }

        [TestMethod]
        public void TestSameScore()
        {
            // According to the ordered set rule, the same
            // score after the insertion will be traversed
            // to the priority
            sortset.Add(10, 10);
            sortset.Add(90, 10);
            sortset.Add(20, 10);
            sortset.Add(80, 10);

            var actual = sortset.ToArray();

            Assert.AreEqual(80, actual[0]);
            Assert.AreEqual(20, actual[1]);
            Assert.AreEqual(90, actual[2]);
            Assert.AreEqual(10, actual[3]);
        }

        [TestMethod]
        public void TestRemoveNotExistsElement()
        {
            Assert.IsFalse(sortset.Remove(8888));
        }

        [TestMethod]
        [ExpectedException(typeof(InvalidOperationException))]
        public void TestPopEmpty()
        {
            sortset.Pop();
        }

        [TestMethod]
        [ExpectedException(typeof(InvalidOperationException))]
        public void TestShiftEmpty()
        {
            sortset.Shift();
        }

        [TestMethod]
        public void TestIterationsDeleted()
        {
            for (var i = 0; i < 100; i++)
            {
                sortset.Add(i, i);
            }

            var expected = new List<int>() { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90 };
            var actuals = new List<int>();
            foreach (var i in sortset)
            {
                actuals.Add(i);
                sortset.Remove(i);
                sortset.Remove(i + 1);
                sortset.Remove(i + 2);
                sortset.Remove(i + 3);
                sortset.Remove(i + 4);
                sortset.Remove(i + 5);
                sortset.Remove(i + 6);
                sortset.Remove(i + 7);
                sortset.Remove(i + 8);
                sortset.Remove(i + 9);
            }

            var n = 0;
            foreach (var actual in actuals)
            {
                Assert.AreEqual(expected[n++], actual);
            }

            Assert.AreEqual(expected.Count, actuals.Count);
        }

        [TestMethod]
        [ExpectedException(typeof(KeyNotFoundException))]
        public void TestGetScoreNotFound()
        {
            sortset.GetScore(100);
        }

        private class PriorityComparer : IComparer<int>
        {
            public int Compare(int x, int y)
            {
                return y - x;
            }
        }
    }
}


================================================
FILE: src/CatLib.Core.Tests/Util/TestsStr.cs
================================================
/*
 * This file is part of the CatLib package.
 *
 * (c) CatLib <support@catlib.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Document: https://catlib.io/
 */

using CatLib.Util;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Text;
using System.Text.RegularExpressions;

namespace CatLib.Tests.Util
{
    [TestClass]
    public class TestsStr
    {
        [TestMethod]
        [DataRow(@"foo\.\?\+/bar/ba.*?z", "foo.?+/bar/ba*z", "Special characters should be escaped")]
        public void TestAsteriskWildcard(string expected, string input, string message)
        {
            Assert.AreEqual(expected, Str.AsteriskWildcard(input), message);
        }

        [TestMethod]
        [DataRow(true, "foo.?+/bar/b*z", "foo.?+/bar/baz")]
        [DataRow(true, "foob*r", "fooboooooooor")]
        [DataRow(true, "foo", "foo")]
        [DataRow(false, "foo.?+/bar/b*z", "foobar.?+/bar/baz")]
        [DataRow(false, "foob*r", "fooboooooooorp")]
        public void TestIs(bool expected, string pattern, string value)
        {
            Assert.AreEqual(expected, Str.Is(pattern, value));
        }

        [TestMethod]
        public void TestSplit()
        {
            var actual = Str.Split("foobaro", 2);
            Assert.AreEqual("fo", actual[0]);
            Assert.AreEqual("ob", actual[1]);
            Assert.AreEqual("ar", actual[2]);
            Assert.AreEqual("o", actual[3]);
            Assert.AreEqual(4, actual.Length);

            actual = Str.Split("foobar", 2);
            Assert.AreEqual("fo", actual[0]);
            Assert.AreEqual("ob", actual[1]);
            Assert.AreEqual("ar", actual[2]);
            Assert.AreEqual(3, actual.Length);
        }

        [TestMethod]
        public void TestSplitEmpty()
        {
            var actual = Str.Split(string.Empty, 2);
            Assert.AreEqual(0, actual.Length);
        }

        [TestMethod]
        public void TestRepeat()
        {
            Assert.AreEqual("foofoo", Str.Repeat("foo", 2));
            Assert.AreEqual("foo", Str.Repeat("foo", 1));
            Assert.AreEqual(string.Empty, Str.Repeat("foo", 0));
        }

        [TestMethod]
        public void TestShuffle()
        {
            var i = 0;
            var foo = "foobar";
            while (Str.Shuffle(foo) == "foobar")
            {
                if (i++ > 1000)
                {
                    Assert.Fail("Must disturb the string.");
                }
            }
        }

        [TestMethod]
        public void TestShuffleEmpty()
        {
            Assert.AreEqual(string.Empty, Str.Shuffle(string.Empty));
        }

        [TestMethod]
        public void TestSubstringCount()
        {
            var count = Str.SubstringCount("foobarbaz", "ba");
            Assert.AreEqual(2, count);

            count = Str.SubstringCount("foobar", "o");
            Assert.AreEqual(2, count);

            count = Str.SubstringCount("foobarbaz", "b", 5);
            Assert.AreEqual(1, count);

            count = Str.SubstringCount("foobarfoobar", "r", 5, 5);
            Assert.AreEqual(1, count);

            count = Str.SubstringCount("foobar", "l", 0, null, StringComparison.CurrentCulture);
            Assert.AreEqual(0, count);

            count = Str.SubstringCount("abcabcab", "abcab");
            Assert.AreEqual(1, count);

            count = Str.SubstringCount(string.Empty, "foo");
            Assert.AreEqual(0, count);
        }

        [TestMethod]
        public void TestSubstringStartLargeThanLength()
        {
            Assert.AreEqual(0, Str.SubstringCount("foobar", "foo", 999, 9));
        }

        [TestMethod]
        public void TestReverse()
        {
            Assert.AreEqual("oof", Str.Reverse("foo"));
        }

        [TestMethod]
        public void TestPad()
        {
            var actual = Str.Pad(10, "foo", "barbaz", Str.PadType.Both);
            Assert.AreEqual("barfoobarb", actual);

            actual = Str.Pad(10, "foo", "barbaz");
            Assert.AreEqual("foobarbazb", actual);

            actual = Str.Pad(10, "foo", "barbaz", Str.PadType.Left);
            Assert.AreEqual("barbazbfoo", actual);

            actual = Str.Pad(3, "foo", "barbaz", Str.PadType.Left);
            Assert.AreEqual("foo", actual);

            actual = Str.Pad(10, "foo", null, Str.PadType.Left);
            Assert.AreEqual("       foo", actual);

            actual = Str.Pad(10, "foo", string.Empty, Str.PadType.Left);
            Assert.AreEqual("       foo", actual);
        }

        [TestMethod]
        public void TestStrPadEmpty()
        {
            var actual = Str.Pad(10, string.Empty, "foo", Str.PadType.Left);
            Assert.AreEqual("foofoofoof", actual);

            actual = Str.Pad(10, string.Empty, "foobar", Str.PadType.Both);
            Assert.AreEqual("foobafooba", actual);

            actual = Str.Pad(10, null, "foobar");
            Assert.AreEqual("foobarfoob", actual);
        }

        [TestMethod]
        [DataRow("bar", "foobar", "foo")]
        [DataRow("bar", "foobar", "oo")]
        [DataRow("", "foobar", "bar")]
        [DataRow("foobar", "foobar", "baz")]
        public void TestAfter(string expected, string value, string search)
        {
            Assert.AreEqual(expected, Str.After(value, search));
        }

        [TestMethod]
        public void TestContains()
        {
            Assert.AreEqual(true, Str.Contains("foobar", "baz", "foo"));
            Assert.AreEqual(false, Str.Contains("foobar", "baz", "aux"));
        }

        [TestMethod]
        public void TestReplace()
        {
            var actual = Str.Replace(new[] { "+", "-", "bar" }, string.Empty, "fo+obar,f-+oobar");
            Assert.AreEqual("foo,foo", actual);

            actual = Str.Replace(new[] { "+", "-", "oo" }, string.Empty, "fo+obar,f-+oobar");
            Assert.AreEqual("fbar,fbar", actual);
        }

        [TestMethod]
        public void TestReplaceFirst()
        {
            var actual = Str.ReplaceFirst("foo", "baz", "foobar,foobar");
            Assert.AreEqual("bazbar,foobar", actual);

            actual = Str.ReplaceFirst("bar", "baz", "foo,bar");
            Assert.AreEqual("foo,baz", actual);
        }

        [TestMethod]
        public void TestReplaceLast()
        {
            var actual = Str.ReplaceLast("foo", "baz", "foobar,foobar");
            Assert.AreEqual("foobar,bazbar", actual);

            actual = Str.ReplaceLast("foobar", "baz", "foobar,foobar");
            Assert.AreEqual("foobar,baz", actual);
        }

        [TestMethod]
        public void TestRandom()
        {
            var i = 0;
            var str = Str.Random();
            while (Str.Random() == str)
            {
                if (i++ > 1000)
                {
                    Assert.Fail("Need random numbers.");
                }
            }

            Assert.AreEqual(16, str.Length, "The random length defaults to 16.");
        }

        [TestMethod]
        public void TestSpace()
        {
            Assert.AreEqual(" ", Str.Space);
        }

        [TestMethod]
        public void TestTruncate()
        {
            var actual = Str.Truncate("hello world , the sun is shine", 11);
            Assert.AreEqual("hello wo...", actual);

            actual = Str.Truncate("hello world , the sun is shine", 11, Str.Space);
            Assert.AreEqual("hello...", actual);

            actual = Str.Truncate("hello world , the sun is shine", 15, Str.Space);
            Assert.AreEqual("hello world...", actual);

            actual = Str.Truncate("hello world sun sname", 15, Str.Space);
            Assert.AreEqual("hello world...", actual);

            var regex = new Regex("orl");
            actual = Str.Truncate("hello worldrldddorl sun sname", 15, regex);
            Assert.AreEqual("hello w...", actual);

            regex = new Regex("rld");
            actual = Str.Truncate("hello worldrldddorl sun sname", 17, regex);
            Assert.AreEqual("hello world...", actual);

            actual = Str.Truncate(null, 17, regex);
            Assert.AreEqual(null, actual);

            actual = Str.Truncate("hello world", 17, regex);
            Assert.AreEqual("hello world", actual);

            regex = new Regex("rld", RegexOptions.RightToLeft);
            actual = Str.Truncate("hello worldrldddorl sun sname", 17, regex);
            Assert.AreEqual("hello world...", actual);

            actual = Str.Truncate("hel", 2);
            Assert.AreEqual("...", actual);

            actual = Str.Truncate(string.Empty, -1);
            Assert.AreEqual("...", actual);

            actual = Str.Truncate("喵h喵e越l来l越l漂o亮!了", 12, "l");
            Assert.AreEqual("喵h喵e越l来...", actual);

            actual = Str.Truncate("喵h喵e越l来l越l漂o亮!了", 12);
            Assert.AreEqual("喵h喵e越l来l越...", actual);
        }

        [TestMethod]
        public void TestMethod()
        {
            Assert.AreEqual("GetNameSpace", Str.Method("Helloworld.GetNameSpace"));
            Assert.AreEqual("GetNameSpace", Str.Method("Helloworld.GetNameSpace()"));
            Assert.AreEqual("Space", Str.Method("Helloworld.GetName@Space()"));
            Assert.AreEqual("_Space", Str.Method("Helloworld.GetName@_Space()"));
            Assert.AreEqual("g8975GetNameSpace", Str.Method("Helloworld.g8975GetNameSpace()"));
            Assert.AreEqual("GetNameSpace", Str.Method("Helloworld.8975GetNameSpace()"));
            Assert.AreEqual("ame_Space", Str.Method("Helloworld.8975GetN(;)ame_Space()"));
            Assert.AreEqual("GetName_Space", Str.Method("Helloworld.8GetName_Space()"));
            Assert.AreEqual(string.Empty, Str.Method(null));
            Assert.AreEqual(string.Empty, Str.Method(string.Empty));
        }

        [TestMethod]
        public void TestIsArray()
        {
            var actual = Arr.Filter(
                new string[]
            {
                "CatLib.Core",
                "CatLib.ILRuntime",
                "CatLib.Route",
                "Hello.World",
            }, (assembly) => Str.Is(
                new string[]
            {
                "CatLib.*",
            }, assembly));

            CollectionAssert.AreEqual(
                new[]
                {
                    "CatLib.Core",
                    "CatLib.ILRuntime",
                    "CatLib.Route",
                }, actual);
        }

        [TestMethod]
        public void TestLevenshtein()
        {
            Assert.AreEqual(4, Str.Levenshtein("hello", "world"));
            Assert.AreEqual(5, Str.Levenshtein("hello", "catlib"));
            Assert.AreEqual(10, Str.Levenshtein("hello", "catlib-world"));
        }

        [TestMethod]
        public void TestLevenshteinLargeThan255()
        {
            var builder = new StringBuilder(256);
            for (var i = 0; i < 256; i++)
            {
                builder.Append('a');
            }

            Assert.AreEqual(256, builder.Length);
            Assert.AreEqual(-1, Str.Levenshtein(builder.ToString(), "foo"));
        }

        [TestMethod]
        public void TestLevenshteinNull()
        {
            Assert.AreEqual(-1, Str.Levenshtein(null, "foo"));
        }

        [TestMethod]
        public void TestJoinList()
        {
            var actual = Str.JoinList(new[] { "foo", "bar", "baz" }, "/");

            CollectionAssert.AreEqual(
                new[]
                {
                    "foo",
                    "foo/bar",
                    "foo/bar/baz",
                }, actual);
        }

        [TestMethod]
        public void TestJoinListChar()
        {
            var actual = Str.JoinList(new[] { "foo", "bar", "baz" }, '@');

            CollectionAssert.AreEqual(
                new[]
                {
                    "foo",
                    "foo@bar",
                    "foo@bar@baz",
                }, actual);
        }
    }
}


================================================
FILE: src/Directory.Build.props
================================================
<Project>
  <PropertyGroup>
	<IsTestProject>$(MSBuildProjectName.Contains('Tests'))</IsTestProject>
	<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  <WarningsAsErrors />
  </PropertyGroup>
  
  <ItemGroup>
	  <AdditionalFiles Include="$(MSBuildThisFileDirectory)stylecop.json" Link="stylecop.json" />
  </ItemGroup>

  <ItemGroup>
      <PackageReference Include="Microsoft.CodeAnalysis.CSharp" PrivateAssets="all" Version="3.3.1" />
      <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" PrivateAssets="all" Version="2.9.6" />
      <PackageReference Include="StyleCop.Analyzers" Version="1.1.118">
        <PrivateAssets>all</PrivateAssets>
        <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
      </PackageReference>
      <PackageReference Include="SonarAnalyzer.CSharp" Version="7.17.0.9346">
        <PrivateAssets>all</PrivateAssets>
        <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
      </PackageReference>
  </ItemGroup>

  <Choose>
	<When Condition="'$(IsTestProject)' == 'true'">
	  <PropertyGroup>
        <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)analysis.test.ruleset</CodeAnalysisRuleSet>
    </PropertyGroup>
	  
	  <ItemGroup>
		<PackageReference Include="coverlet.msbuild" Version="2.7.0">
		  <PrivateAssets>all</PrivateAssets>
		  <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
		</PackageReference>
		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
		<PackageReference Include="Moq" Version="4.13.0" />
		<PackageReference Include="MSTest.TestAdapter" Version="2.0.0" />
		<PackageReference Include="MSTest.TestFramework" Version="2.0.0" />
	  </ItemGroup>
	</When>
	<Otherwise>
	  <PropertyGroup>
        <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)analysis.ruleset</CodeAnalysisRuleSet>
    </PropertyGroup>
	</Otherwise>
  </Choose>
</Project>

================================================
FILE: src/analysis.ruleset
================================================
<?xml version="1.0" encoding="utf-8"?>
<RuleSet Name="CatLib Code Analysis Ruleset" Description="The catlib code analysis ruleset" ToolsVersion="10.0">
  <Rules AnalyzerId="Microsoft.NetCore.Analyzers" RuleNamespace="Microsoft.NetCore.Analyzers">
	<Rule Id="CA1051" Action="Error" /> <!-- Do not declare visible instance fields -->
	<Rule Id="CA1034" Action="Error" /> <!-- Nested types should not be visible -->
	<Rule Id="CA1716" Action="Error" /> <!-- Test for empty strings using string length -->
	<Rule Id="CA1720" Action="Error" /> <!-- Identifiers should not contain type names -->
	<Rule Id="CA1307" Action="Error" /> <!-- Specify stringcomparison -->
	<Rule Id="CA1820" Action="Error" /> <!-- Test for empty strings using string length -->
	
	<Rule Id="CA1032" Action="None" /> <!-- Implement standard exception constructors -->
	<Rule Id="CA1062" Action="None" /> <!-- Validate arguments of public methods -->
	<Rule Id="CA1303" Action="None" /> <!-- Do not pass literals as localized parameters -->
	<Rule Id="CA1304" Action="None" /> <!-- Specify CultureInfo -->
	<Rule Id="CA1305" Action="None" /> <!-- Specify iformatprovider -->
	<Rule Id="CA1810" Action="None" /> <!-- Initialize reference type static fields inline -->
  </Rules>
  <Rules AnalyzerId="Microsoft.CodeQuality.Analyzers" RuleNamespace="Microsoft.CodeQuality.Analyzers">
	<Rule Id="CA1031" Action="Error" /> <!-- Do not catch general exception types -->
	<Rule Id="CA1052" Action="Error" /> <!-- Static holder types should be sealed -->
	<Rule Id="CA1710" Action="Error" /> <!-- Identifiers should have correct suffix -->
	<Rule Id="CA1819" Action="Error" /> <!-- Properties should not return arrays -->
    <Rule Id="CA1825" Action="Error" /> <!-- Avoid zero-length array allocations -->
	<Rule Id="CA1724" Action="None" /> <!-- Type names should not match the names of namespaces -->
  </Rules>
  <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
	<Rule Id="SA1101" Action="None" /> <!-- A call to an instance member of the local class or a base class is not prefixed with this -->
	<Rule Id="SA1117" Action="None" /> <!-- Parameters must be on same line or separate lines -->
	<Rule Id="SA1118" Action="None" /> <!-- Parameter must not span multiple lines -->
	<Rule Id="SA1208" Action="None" /> <!-- System using directives must be placed before other using directives -->
	<Rule Id="SA1633" Action="None" /> <!-- File must have header -->
	<Rule Id="SA0001" Action="None" /> <!-- Xml comment analys is disabled -->
  </Rules>
  <Rules AnalyzerId="SonarAnalyzer.CSharp" RuleNamespace="SonarAnalyzer.CSharp">
	<Rule Id="S907" Action="None" /> <!-- "goto" statement should not be used -->
	<Rule Id="S1135" Action="None" /> <!-- Track uses of "TODO" tags -->
	<Rule Id="S3925" Action="None" /> <!-- "ISerializable" should be implemented correctly -->
  </Rules>
</RuleSet>

================================================
FILE: src/analysis.test.ruleset
================================================
<?xml version="1.0" encoding="utf-8"?>
<RuleSet Name="CatLib Code Analysis Ruleset" Description="The catlib code analysis ruleset" ToolsVersion="10.0">
  <Include Path="analysis.ruleset" Action="Default" />
  <Rules AnalyzerId="Microsoft.CodeQuality.Analyzers" RuleNamespace="Microsoft.CodeQuality.Analyzers">
	<Rule Id="CA2000" Action="None" /> <!-- Call IDisposable.Dispose -->
  </Rules>
  <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
	<Rule Id="SA1600" Action="None" /> <!-- Elements must be documented -->
  </Rules>
  <Rules AnalyzerId="SonarAnalyzer.CSharp" RuleNamespace="SonarAnalyzer.CSharp">
	<Rule Id="S1121" Action="None" /> <!-- Assignments should not be made from within sub-expressions -->
	<Rule Id="S2699" Action="None" /> <!-- Tests should include assertions -->
	<Rule Id="S2187" Action="None" /> <!-- Add some tests in the file -->
  </Rules>
</RuleSet>

================================================
FILE: src/settings.runsettings
================================================
<?xml version="1.0" encoding="utf-8"?>  
<RunSettings>
	<RunConfiguration>    
		<ResultsDirectory>%temp%\TestResults</ResultsDirectory>    
	</RunConfiguration>
    <DataCollectionRunSettings>  
    <DataCollectors>  
      <DataCollector friendlyName="Code Coverage" uri="datacollector://Microsoft/CodeCoverage/2.0" assemblyQualifiedName="Microsoft.VisualStudio.Coverage.DynamicCoverageDataCollector, Microsoft.VisualStudio.TraceCollector, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">  
        <Configuration>  
          <CodeCoverage>  
            <ModulePaths>  
              <Exclude>  
                <ModulePath>.*\.tests\.dll$</ModulePath>
              </Exclude>  
            </ModulePaths>
            <Attributes>
              <Exclude>
                <Attribute>.*\.ExcludeFromCodeCoverageAttribute$</Attribute>
              </Exclude>
            </Attributes>
            <Sources>
              <Exclude>
                <Source>.*\\3rd\\.*</Source>
				<Source>.*\\Vendor\\.*</Source>
				<Source>.*\\Exception\\.*</Source>
              </Exclude>
            </Sources>
          </CodeCoverage>  
        </Configuration>  
      </DataCollector>  
    </DataCollectors>  
  </DataCollectionRunSettings>  
</RunSettings> 

================================================
FILE: src/stylecop.json
================================================
{
  "settings":{
    "orderingRules":{
        "usingDirectivesPlacement" : "outsideNamespace"
    },
	"documentationRules":{
		"documentInternalElements" : false
	},
	"readabilityRules":{
		"allowBuiltInTypeAliases": true
	},
	"maintainabilityRules":{
		"topLevelTypes" : [ 
			"class",
			"interface",
			"enum",
			"delegate",
			"struct"
		]
	},
	"layoutRules":{
		"newlineAtEndOfFile" : "require"
	}
  }
}