ටීඑල්; ඩී.ආර්
අස්ථිර වස්තූන් සැමවිටම වෙනස් ය; සෑම පාලකයකුටම සහ සෑම සේවාවක් සඳහාම නව අවස්ථාවක් සපයනු ලැබේ.
විෂය පථය වස්තු ඉල්ලීමක් තුළ සමාන වේ, නමුත් විවිධ ඉල්ලීම් අතර වෙනස් වේ.
සෑම වස්තුවකටම සහ සෑම ඉල්ලීමකටම සිංගල්ටන් වස්තු සමාන වේ.
වැඩි පැහැදිලි කිරීමක් සඳහා, ASP.NET ප්‍රලේඛනයේ මෙම උදාහරණයේ වෙනස පෙන්වයි:
මෙම ජීවිත කාලය සහ ලියාපදිංචි කිරීමේ විකල්ප අතර වෙනස නිරූපණය කිරීම සඳහා, අද්විතීය හඳුනාගැනීමක් සහිත මෙහෙයුමක් ලෙස කාර්යයන් එකක් හෝ කිහිපයක් නියෝජනය කරන සරල අතුරු මුහුණතක් සලකා බලන්න , OperationId. මෙම සේවාව සඳහා අපි ජීවිත කාලය වින්‍යාස කරන ආකාරය මත පදනම්ව, කන්ටේනරය ඉල්ලුම් කරන පන්තියට සේවාවේ සමාන හෝ වෙනස් අවස්ථා ලබා දෙනු ඇත. කුමන ජීවිත කාලය ඉල්ලා සිටිනවාද යන්න පැහැදිලි කිරීම සඳහා, අපි එක් ජීවිත කාලයක් සඳහා එක් වර්ගයක් නිර්මාණය කරමු:
using System;
namespace DependencyInjectionSample.Interfaces
{
public interface IOperation
{
Guid OperationId { get; }
}
public interface IOperationTransient : IOperation
{
}
public interface IOperationScoped : IOperation
{
}
public interface IOperationSingleton : IOperation
{
}
public interface IOperationSingletonInstance : IOperation
{
}
}
අපි මෙම අතුරුමුහුණත් ක්‍රියාත්මක කරන්නේ තනි පන්තියක් භාවිතා කරමිනි, Operationඑය එහි ඉදිකිරීම්කරු තුළ GUID එකක් පිළිගනී, නැතහොත් කිසිවක් ලබා නොදුනහොත් නව GUID භාවිතා කරයි:
using System;
using DependencyInjectionSample.Interfaces;
namespace DependencyInjectionSample.Classes
{
public class Operation : IOperationTransient, IOperationScoped, IOperationSingleton, IOperationSingletonInstance
{
Guid _guid;
public Operation() : this(Guid.NewGuid())
{
}
public Operation(Guid guid)
{
_guid = guid;
}
public Guid OperationId => _guid;
}
}
ඊළඟට, දී ConfigureServices, එක් එක් වර්ගය එහි නම් කරන ලද ජීවිත කාලය අනුව බහාලුමට එකතු කරනු ලැබේ:
services.AddTransient<IOperationTransient, Operation>();
services.AddScoped<IOperationScoped, Operation>();
services.AddSingleton<IOperationSingleton, Operation>();
services.AddSingleton<IOperationSingletonInstance>(new Operation(Guid.Empty));
services.AddTransient<OperationService, OperationService>();
IOperationSingletonInstanceසේවාව දන්නා හැඳුනුම්පතක් සමඟ නිශ්චිත අවස්ථාවක් භාවිතා කරන බව සලකන්න Guid.Empty, එබැවින් මෙම වර්ගය භාවිතා වන විට එය පැහැදිලි වනු ඇත. OperationServiceඅනෙක් සෑම Operationවර්ගයක් මත රඳා පවතින එකක් ද අප ලියාපදිංචි කර ඇති අතර , එමඟින් එක් එක් මෙහෙයුම් වර්ගය සඳහා මෙම සේවාව පාලකයට සමානද, නැතහොත් නව එකක්ද යන්න ඉල්ලීමක් තුළ පැහැදිලි වනු ඇත. මෙම සේවාව කරන්නේ එහි පරායත්තතාවයන් ගුණාංග ලෙස නිරාවරණය කිරීමයි, එබැවින් ඒවා දර්ශනයේ පෙන්විය හැකිය.
using DependencyInjectionSample.Interfaces;
namespace DependencyInjectionSample.Services
{
public class OperationService
{
public IOperationTransient TransientOperation { get; }
public IOperationScoped ScopedOperation { get; }
public IOperationSingleton SingletonOperation { get; }
public IOperationSingletonInstance SingletonInstanceOperation { get; }
public OperationService(IOperationTransient transientOperation,
IOperationScoped scopedOperation,
IOperationSingleton singletonOperation,
IOperationSingletonInstance instanceOperation)
{
TransientOperation = transientOperation;
ScopedOperation = scopedOperation;
SingletonOperation = singletonOperation;
SingletonInstanceOperation = instanceOperation;
}
}
}
යෙදුමට වෙන වෙනම ඉල්ලීම් ඇතුළත සහ ඒවා අතර වස්තු ආයු කාලය නිරූපණය කිරීම සඳහා, නියැදියට OperationsControllerඑක් එක් වර්ගයේ ඉල්ලීම් IOperationමෙන්ම a OperationService. මෙම Indexපියවර පසුව පාලකය ගේ හා සේවා ගේ දර්ශනය OperationIdවටිනාකම්.
using DependencyInjectionSample.Interfaces;
using DependencyInjectionSample.Services;
using Microsoft.AspNetCore.Mvc;
namespace DependencyInjectionSample.Controllers
{
public class OperationsController : Controller
{
private readonly OperationService _operationService;
private readonly IOperationTransient _transientOperation;
private readonly IOperationScoped _scopedOperation;
private readonly IOperationSingleton _singletonOperation;
private readonly IOperationSingletonInstance _singletonInstanceOperation;
public OperationsController(OperationService operationService,
IOperationTransient transientOperation,
IOperationScoped scopedOperation,
IOperationSingleton singletonOperation,
IOperationSingletonInstance singletonInstanceOperation)
{
_operationService = operationService;
_transientOperation = transientOperation;
_scopedOperation = scopedOperation;
_singletonOperation = singletonOperation;
_singletonInstanceOperation = singletonInstanceOperation;
}
public IActionResult Index()
{
// ViewBag contains controller-requested services
ViewBag.Transient = _transientOperation;
ViewBag.Scoped = _scopedOperation;
ViewBag.Singleton = _singletonOperation;
ViewBag.SingletonInstance = _singletonInstanceOperation;
// Operation service has its own requested services
ViewBag.Service = _operationService;
return View();
}
}
}
දැන් මෙම පාලක ක්‍රියාව සඳහා වෙනම ඉල්ලීම් දෙකක් කරනු ලැබේ:
OperationIdඉල්ලීමක් තුළ සහ ඉල්ලීම් අතර වෙනස් වන අගයන් මොනවාදැයි නිරීක්ෂණය කරන්න .
අස්ථිර වස්තූන් සැමවිටම වෙනස් ය; සෑම පාලකයකුටම සහ සෑම සේවාවක් සඳහාම නව අවස්ථාවක් සපයනු ලැබේ.
විෂය පථය වස්තු ඉල්ලීමක් තුළ සමාන වේ, නමුත් විවිධ ඉල්ලීම් අතර වෙනස් වේ
සිංගල්ටන් වස්තූන් සෑම වස්තුවකටම සහ සෑම ඉල්ලීමකටම සමාන වේ (නිදසුනක් සපයා තිබේද යන්න නොසලකා ConfigureServices)
