ASP.NET అనేది C # మరియు .NET తో వెబ్ API లను నిర్మించడానికి ఒక వేదిక. ఇది సాధారణంగా అనువర్తన బ్యాకెండ్‌ల కోసం ఉపయోగించబడుతుంది మరియు స్వయంచాలకంగా తరగతులను JSON కు సీరియల్ చేయవచ్చు. డేటాబేస్తో మాట్లాడే మరియు వస్తువుల జాబితాను నిల్వ చేసే సేవను ఏర్పాటు చేయడం ద్వారా మేము వెళ్తాము.

ప్రాజెక్ట్ను సృష్టిస్తోంది

మేము విజువల్ స్టూడియోని ఉపయోగిస్తాము, ఎందుకంటే ఇది వెలుపల పెట్టె .NET మద్దతును అందిస్తుంది. “ASP.NET కోర్ వెబ్ అప్లికేషన్” టెంప్లేట్ ఉపయోగించి క్రొత్త ప్రాజెక్ట్ను సృష్టించండి:

క్రొత్త ప్రాజెక్ట్ను సృష్టించండి

మేము ఇక్కడ ASP.NET ఫ్రంటెండ్‌ను సృష్టించనందున దీనికి ఒక పేరు ఇవ్వండి మరియు “API” ఎంచుకోండి.

API ఎంచుకోండి

ఇది ప్రాథమిక API ని పొందడానికి మరియు అమలు చేయడానికి అవసరమైన అన్ని బాయిలర్‌ప్లేట్‌తో మీ పరిష్కారాన్ని ప్రారంభిస్తుంది. మీరు రన్ బటన్‌ను క్లిక్ చేస్తే (IIS వెబ్ సర్వర్‌ను ప్రారంభించే IIS ఎక్స్‌ప్రెస్ లేబుల్), మీరు కొన్ని డమ్మీ వాతావరణ డేటాను చూపించే API ని చూస్తారు.

ప్రోగ్రామ్ ప్రారంభించండి

డమ్మీ డేటా

డేటాబేస్కు కనెక్ట్ అయ్యే మరియు అనుకూల వస్తువులను చదవడానికి మరియు వ్రాయడానికి సరళమైన API ని సెటప్ చేయడానికి మేము ఈ బేస్ను ఉపయోగిస్తాము. ఈ సందర్భంలో, ఇది వినియోగదారు డేటా సమాహారం, కానీ మరింత క్లిష్టమైన ఎంటిటీ మోడళ్ల కోసం API చాలావరకు ఒకే విధంగా పనిచేస్తుంది.

డేటాబేస్ను కనెక్ట్ చేస్తోంది

అభ్యర్ధనల నిర్వహణ యొక్క తర్కాన్ని మరియు డేటాబేస్ సంభాషణలను నిర్వహించే తర్కాన్ని విభజించడం మంచిది. మేము కొన్ని రీడ్ అండ్ రైట్ ఫంక్షన్లతో డేటాబేస్ సేవను సృష్టిస్తాము, ఆపై డేటాబేస్ సేవతో మాట్లాడటం ద్వారా అభ్యర్థనలకు ప్రతిస్పందించే API కంట్రోలర్. అయితే, మొదట చేయవలసినది ఏమిటంటే, మొదట ASP.NET ను డేటాబేస్ తో మాట్లాడటం.

డేటాబేస్తో పనిచేయడానికి మేము కొన్ని ప్యాకేజీలను వ్యవస్థాపించాలి. ఉపకరణాలు> నుగెట్ ప్యాకేజీ నిర్వాహికి క్లిక్ చేసి, “పరిష్కారం కోసం నుగెట్ ప్యాకేజీలను నిర్వహించు” ఎంచుకోండి.

చిన్న ప్యాకేజీలను వ్యవస్థాపించండి

మీరు SQL డేటాబేస్ ఉపయోగిస్తుంటే, డేటాబేస్కు కనెక్షన్ నిర్దిష్ట ప్లగ్-ఇన్ ప్యాకేజీలతో నిర్వహించబడుతుంది, ఇది అంతర్లీన డేటాబేస్ కోసం ఎంటిటీఫ్రేమ్వర్క్కోర్ను అమలు చేస్తుంది. ఇది సి # వస్తువులను రిలేషనల్ డేటాబేస్కు మ్యాప్ చేసే ఫ్రేమ్‌వర్క్ మరియు దానితో సంభాషించడానికి LINQ ప్రశ్నలు మరియు ఇతర స్థానిక సాధనాలను ఉపయోగించడానికి మిమ్మల్ని అనుమతిస్తుంది. అత్యంత ప్రాచుర్యం పొందిన రిలేషనల్ డేటాబేస్ల కోసం మీరు ఇక్కడ డేటాబేస్ ప్రొవైడర్ల పూర్తి జాబితాను కనుగొనవచ్చు.

మేము ఇక్కడ మొంగోడిబితో వెళ్తాము, ఎందుకంటే NoSQL డాక్యుమెంట్ డేటాబేస్లు a List చాలా సులభంగా మరియు మొంగోడిబి డ్రైవర్ EF కోర్ వంటి LINQ ప్రశ్నలకు మద్దతు ఇస్తుంది.

మొంగోడిబి.డ్రైవర్ ప్యాకేజీని ఇన్‌స్టాల్ చేయండి:

మొంగోడిబి.డ్రైవర్ ప్యాకేజీని ఇన్‌స్టాల్ చేస్తోంది

మీ ప్రాజెక్ట్ యొక్క మూలంలో “టెంప్లేట్లు” అని పిలువబడే క్రొత్త ఫోల్డర్‌ను సృష్టించండి. అందులో, ఇది అనే ఎంటిటీ మోడల్‌ను సృష్టిస్తుంది User.cs, ఇది డేటాబేస్లో నిల్వ చేయబడే సేకరణకు స్కీమా అవుతుంది. మీరు ఫైల్ను ఉపయోగించవచ్చు [BsonId] ఉంది [BsonRepresentation(BsonType.ObjectId)] మొంగోడిబి డ్రైవర్‌కు ఈ ఐడి స్ట్రింగ్‌ను సేకరణ ఐడిగా అర్థం చేసుకోవాలని మరియు ఒక రకంగా పంపించవచ్చని చెప్పడానికి గుణాలు string మొంగో అంతర్గతంగా రకాన్ని కోరుకున్నా ObjectId.

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using System;

namespace ExampleService.Models
{
    public class User
    {
        [BsonId]
        [BsonRepresentation(BsonType.ObjectId)]
        public string Id { get; set; }
        
        [BsonElement("Name")]
        public string Name { get; set; }
        public string Email { get; set; }
        // etc...
    }
}

ఇదే ఫోల్డర్‌లో, అనే ఫైల్‌ను సృష్టించండి DatabaseSettings.cs, ఇది డేటాబేస్ సెట్టింగుల కోసం తరగతి మరియు ఇంటర్ఫేస్ను నిల్వ చేస్తుంది.

namespace ExampleService.Models
{
    public class ExampleDatabaseSettings : IExampleDatabaseSettings
    {
        public string ExampleCollectionName { get; set; }
        public string ConnectionString { get; set; }
        public string DatabaseName { get; set; }
    }

    public interface IExampleDatabaseSettings
    { 
        string ExampleCollectionName { get; set; }
        string ConnectionString { get; set; }
        string DatabaseName { get; set; }
    }
}

మేము ఈ ఆస్తి విలువలను జనాభాలో ఉంచవచ్చు appsettings.json, కింది కాన్ఫిగరేషన్‌ను జతచేస్తుంది:

"ExampleDatabaseSettings": {
    "ExampleCollectionName": "Users",
    "ConnectionString": "mongodb://localhost:27017",
    "DatabaseName": "Example"
}

వాస్తవానికి మీరు ఫైల్‌ను సృష్టించాలి లేదా పేరు మార్చాలి Example డేటాబేస్, అలాగే సృష్టించండి Users అందులో సేకరణ.

చివరగా, మేము కొన్ని కోడ్లను జోడిస్తాము Startup.cs లో ConfigureServices పద్ధతి, ఇది ఫైల్ నుండి సెట్టింగులను తిరిగి పొందుతుంది appsettings.json డిపెండెన్సీ ఇంజెక్షన్ ద్వారా ఇంటర్ఫేస్ను ఫైల్ చేయండి మరియు నమోదు చేయండి:

public void ConfigureServices(IServiceCollection services)
{
    services.Configure(
      Configuration.GetSection(nameof(ExampleDatabaseSettings)));

    services.AddSingleton(sp =>
      sp.GetRequiredService>().Value);

    services.AddControllers();
}

మీరు మీ టెంప్లేట్ నేమ్‌స్పేస్‌ను ఉపయోగించి పైభాగంలో ఆదేశాన్ని జోడించాలి.

CRUD డేటాబేస్ సేవను రాయడం

డేటాబేస్ కనెక్ట్ అయిన తర్వాత, మీరు మాట్లాడే సేవను జోడించవచ్చు. కింది తరగతిలో ఒక ఫైల్ ఉంది IMongoCollection ఇది సి # తో సులభంగా ఇంటరాక్ట్ చేయగల ఫార్మాట్‌లో మొంగోడిబి సేకరణను సూచిస్తుంది. చదవడం, వ్రాయడం, నవీకరణలు మరియు తొలగింపులు అంతర్లీన సేకరణను నేరుగా ప్రభావితం చేస్తాయి.

కన్స్ట్రక్టర్ పద్ధతి డేటాబేస్ సెట్టింగులను తీసుకుంటుంది, క్రొత్త క్లయింట్‌ను ప్రారంభిస్తుంది, డేటాబేస్ను పొందుతుంది, ఆపై ఫైల్‌ను ప్రారంభిస్తుంది _users సేకరణ.

using ExampleService.Models;
using MongoDB.Driver;
using System.Collections.Generic;
using System.Linq;

namespace ExampleService.Services
{
    public class ExampleService
    {
        private readonly IMongoCollection _users;

        public UserService(IExampleDatabaseSettings settings)
        {
            var client = new MongoClient(settings.ConnectionString);
            var database = client.GetDatabase(settings.DatabaseName);

            _users = database.GetCollection(settings.ExampleCollectionName);
        }

        public List Get() =>
            _users.Find(user => true).ToList();

        public User Get(string id) =>
            _users.Find(user => user.Id == id).FirstOrDefault();

        public User Create(User user)
        {
            _users.InsertOne(user);
            return user;
        }

        public void Update(string id, User userIn) =>
            _users.ReplaceOne(user=> user.Id == id, userIn);

        public void Remove(User userIn) =>
            _users.DeleteOne(user => user.Id == userIn.Id);

        public void Remove(string id) => 
            _users.DeleteOne(user=> user.Id == id);
    }
}

మిగిలిన తరగతి కేవలం డేటాబేస్‌తో సంభాషించడానికి CRUD ఆపరేషన్ల సమితి. ఏదైనా అనుకూల తర్కాన్ని ఇక్కడ అమలు చేయడానికి సంకోచించకండి.

మళ్ళీ లోపల Startup.cs, మీరు దీన్ని ప్రారంభంలో సేవగా జోడించాలనుకుంటున్నారు:

public void ConfigureServices(IServiceCollection services)
{
    services.Configure(
      Configuration.GetSection(nameof(ExampleDatabaseSettings)));

    services.AddSingleton(sp =>
      sp.GetRequiredService>().Value);

    services.AddSingleton();

    services.AddControllers();
}

మీకు మళ్ళీ అవసరం using డైరెక్టివ్, ఈసారి ExampleService.Services.

API నియంత్రికను కాన్ఫిగర్ చేస్తోంది

తరువాత, API చర్యలను నిర్వహించడానికి మీకు నియంత్రిక అవసరం. అదృష్టవశాత్తూ, విజువల్ స్టూడియో సులభం చేస్తుంది; చదవడానికి / వ్రాయడానికి చర్యలతో క్రొత్త నియంత్రికను జోడించడానికి మీరు “కంట్రోలర్” పై కుడి క్లిక్ చేయవచ్చు. ఇది కొన్ని ప్రాథమిక పద్ధతులతో కొత్త నియంత్రికను సృష్టిస్తుంది.

కుడి క్లిక్ చేయండి

మార్గం పైన నిర్వచించబడింది. అప్రమేయంగా, ఇది సెట్ చేయబడింది /api/controller, ఇక్కడ నియంత్రిక అనేది నియంత్రిక పేరు (మైనస్ “కంట్రోలర్” భాగం). మీకు నచ్చితే దాన్ని మార్చవచ్చు, కాని ఇది చాలా మందికి మంచి మోడల్.

[Route("api/[controller]")]

మీరు తరగతి ప్రారంభంలో మీ డేటాబేస్ సేవకు సూచనను జోడించి, దానిని కన్స్ట్రక్టర్‌లో జనాదరణ చేయాలి:

private readonly ExampleService _exampleService;

public ExampleController(ExampleService exampleService)
{
    _exampleService = exampleService;
}

ఫైల్‌ను తిరిగి ఇవ్వడానికి మీరు HttpGet పద్ధతిని సవరించాలని మేము సిఫార్సు చేస్తున్నాము ActionResult> మీరు నిల్వ చేస్తున్న పథకం. (మీరు మోడల్ నేమ్‌స్పేస్‌కు సూచనను జోడించాల్సి ఉంటుంది.) యాక్షన్‌ రిసల్ట్ అనేది డైనమిక్ రకం, దీనిలోని టీవీ విలువను లేదా HTTP ప్రతిస్పందన ఫలితాన్ని చుట్టేస్తుంది.

[HttpGet]
public ActionResult> Get()
{
    return _exampleService.Get();
}

మీరు మరొక గెట్ పద్ధతిని జోడించాలనుకుంటే, కానీ వేరే మార్గంలో, మీరు దానిని లక్షణంలో పరామితిగా పంపవచ్చు:

[HttpGet("otherroute")]
public ActionResult> GetSomeThingElse()
{
    return _exampleService.GetSomeThingElse();
}

అప్పుడు HttpPost పద్ధతి కోసం, మీ డేటాబేస్ సేవ యొక్క సృష్టించు పద్ధతిని పిలిచి, CreateAtRoute ని తిరిగి ఇవ్వండి, ఇది ఆబ్జెక్ట్ సృష్టి విజయవంతమైందని క్లయింట్‌కు తెలియజేస్తూ 201 ప్రతిస్పందనను పంపుతుంది.

[HttpPost]
public ActionResult Create(User userIn)
{
    _exampleService.Create(userIn);

    return CreatedAtRoute("GetUser", new { id = userIn.Id.ToString() }, userIn);
}

ఇతర మార్గాల కోసం, మీరు మీకు నచ్చిన విధంగా వాటిని కాన్ఫిగర్ చేయవచ్చు. సాధారణ ఆలోచన ఏమిటంటే, వినియోగదారు ఇన్‌పుట్‌ను నిర్వహించడం, అవసరమైన అన్ని ధృవీకరణలను నిర్వహించడం మరియు సరైన డేటాబేస్ చర్యలను పిలవడం, వినియోగదారుకు ఉపయోగకరమైనదాన్ని తిరిగి ఇవ్వడం లేదా ఏమి జరిగిందో అతనికి చెప్పే స్టేటస్ కోడ్.

అయితే, ఈ సమయంలో, మీరు ఎగువన ఉన్న IIS ఎక్స్‌ప్రెస్ రన్ బటన్‌ను నొక్కండి మరియు API ని పరీక్షించవచ్చు. అప్రమేయంగా, మార్గం బాయిలర్‌ప్లేట్‌తో వచ్చే వాతావరణ సేవల API అవుతుంది, కాబట్టి ప్రతిసారీ దానిని వ్రాసే బదులు, మీరు ప్రాజెక్ట్> ప్రాపర్టీస్> డీబగ్‌లోని డీబగ్ మార్గాన్ని మార్చవచ్చు మరియు లాంచ్ బ్రౌజర్ ఎంపికను మార్చవచ్చు.

డీబగ్ మార్గాన్ని మార్చండి

మీరు రిమోట్ సర్వర్‌లో పరీక్షించాలనుకుంటే, మీరు బిల్డ్> ప్రచురణ సేవ నుండి ఉత్పత్తిని సృష్టించవచ్చు. ఫైల్ యొక్క అవుట్పుట్ను ఎంచుకోండి మరియు మీ అవసరాలకు అనుగుణంగా కాన్ఫిగరేషన్ను సవరించండి. ఉదాహరణకు, మీరు స్వతంత్రంగా కంపైల్ చేయడానికి ఎంచుకోవచ్చు, ఇది కంపైల్‌తో అన్ని .NET డిపెండెన్సీలను కుదించును, మరియు ఒకే ఎక్జిక్యూటబుల్‌గా ప్రచురించడానికి కూడా. మీరు ఇక్కడ లక్ష్య రన్‌టైమ్‌ను కూడా మార్చవచ్చు.

ఉత్పత్తి నిర్మాణ సెట్టింగులు

మీరు Linux లో ప్రచురించాలనుకుంటే, మీరు మీ ఫైల్‌కు రన్‌టైమ్ ఐడెంటిఫైయర్‌ను జోడించాలి .csproj ఫైల్.

linux-x64

సహజంగానే, ఇక్కడ సమర్పించిన API రక్షించబడదు. ASP.NET గొప్ప ప్రామాణీకరణ వ్యవస్థను కలిగి ఉంది, ఇది JWT- ఆధారిత టోకెన్లకు మద్దతునిస్తుంది మరియు గూగుల్ మరియు ఫేస్బుక్ వంటి OAuth ప్రొవైడర్లతో పనిచేయడానికి కాన్ఫిగర్ చేయవచ్చు.

Source link

Post Comment