ASP.NET Kern hohen Speicher verbrauchen
habe ich einige ASP.NET Kern-Projekt und ich war Blick auf Speicher verbraucht. Bekomme ich nur Angst. Seinen keine diesem großen Projekt. Ich habe ein paar regler und es verbraucht abouth 350MB Ram und das ist große Menge an Speicher für den web-server.
Meine Frage ist kann ich das irgendwie reduzieren? Eine Idee, die ich habe, ist Ihnen struct insted Modell für die Daten-Bezug-Modell, aber das wird sich nicht verringern, mutch, wie ich will. Eine andere Weise, ich mag, um zu versuchen, Sie alle 🙂
Und Letzte, was ich jetzt ASP.NET Kern ist ein sehr Komplexes framework, das bedeutet, dass ich nicht verwenden es für kleine Projekte ist dies nur für Bildungs-Zwecken. und Letzte Frage: ist der Speicher-großes problem?
meine größere controler 🙂
using System.Linq;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using RustWiki.Data;
using RustWiki.Models.WikiViewModels;
namespace RustWiki.Controllers.api
{
[Produces("application/json")]
public class TableManagerController : Controller
{
private readonly ApplicationDbContext _context;
public TableManagerController(ApplicationDbContext context)
{
_context = context;
}
protected override void Dispose(bool disposing)
{
_context.Dispose();
base.Dispose(disposing);
}
//Get
[HttpGet]
[Route("/api/ArmorTypes")]
public IActionResult GetArmorTypes() => Ok(_context.ArmorTypes.ToList());
[HttpGet]
[Route("/api/Cloating")]
public IActionResult GetCloating() => Ok(_context.Cloating.Include(c => c.ArmorType).Include(c => c.Defencis).Include(c => c.Item.ItemType).ToList());
[HttpGet]
[Route("/api/Defencis")]
public IActionResult GetDefences() => Ok(_context.Defencis.ToList());
[HttpGet]
[Route("/api/Dmgs")]
public IActionResult GetDmg() => Ok(_context.Dmgs.ToList());
[HttpGet]
[Route("/api/Equipment")]
public IActionResult GetEquipment() => Ok(_context.Equipment.Include(e => e.Dmg).Include(e => e.Item.ItemType).ToList());
[HttpGet]
[Route("/api/Items")]
public IActionResult GetItems() => Ok(_context.Items.Include(i => i.ItemType).ToList());
[HttpGet]
[Route("/api/ItemTypes")]
public IActionResult GetItemType() => Ok(_context.ItemTypes.ToList());
[HttpGet]
[Route("/api/Resources")]
public IActionResult GetResource() => Ok(_context.Resources.ToList());
//Delete
[HttpDelete]
[Route("/api/ArmourTypes/{id}")]
public IActionResult DelArmourType(int id) => Delete(_context.ArmorTypes, id);
[HttpDelete]
[Route("/api/Cloating/{id}")]
public IActionResult DelCloating(int id) => Delete(_context.Cloating, id);
[HttpDelete]
[Route("/api/Defences/{id}")]
public IActionResult DelDefencis(int id) => Delete(_context.Defencis, id);
[HttpDelete]
[Route("/api/Dmgs/{id}")]
public IActionResult DelDmg(int id) => Delete(_context.Dmgs, id);
[HttpDelete]
[Route("/api/Equipments/{id}")]
public IActionResult DelEquipment(int id) => Delete(_context.Equipment, id);
[HttpDelete]
[Route("/api/Items/{id}")]
public IActionResult DelItem(int id) => Delete(_context.Items, id);
[HttpDelete]
[Route("/api/ItemTypes/{id}")]
public IActionResult DelItemType(int id) => Delete(_context.ItemTypes, id);
[HttpDelete]
[Route("/api/Resources/{id}")]
public IActionResult DelResource(int id) => Delete(_context.Resources, id);
private IActionResult Delete<T>(DbSet<T> set, int id) where T : class
{
var obj = set.SingleOrDefault(delegate (T o)
{
return (o as IWikiModel)?.Id == id;
});
if (obj == null)
return NotFound();
set.Remove(obj);
_context.SaveChanges();
return Ok(obj);
}
//Create
[HttpPost]
[Route("/api/ArmourType")]
public IActionResult CreateArmourType([FromBody]ArmorType type)
{
return Ok();
}
}
}
Danke für alle Antworten.
ich war auf der Suche über viele Quellen, und das war ein bisschen verwirrend für mich, aber jetzt bin ich klar. Thank you very mutch.
Ich bin auf der Suche nach einem einfachen asp.net core 2.x-site ist mit ~250mb ram. Dies ist eine schwere Menge oder ram (im Vergleich zu .Netto 4,6 x). Ich war hosting auf cloud-und ich bemerkte dies zuerst als meine app-pool wurde ständig von recycling-300mb-Grenze. Ist das normal und zu erwarten?
InformationsquelleAutor Pavel B. | 2018-03-19
Du musst angemeldet sein, um einen Kommentar abzugeben.
Alle Rahmenbedingungen werden komplexer, neue starter. Mit dieser sagte, .NETCore ist ein viel leichter und optimierte run-time im Vergleich zu den full-frameworks macht es noch mehr lebensfähig für kleine Projekte.
Wenn Sie sagen, dass Ihr API-verbraucht viel Speicher, ist es das wirklich? Was benchmarking sind Sie momentan? Sind Sie es lokal und Blick auf den Speicherverbrauch? Wenn dem so ist, gibt es viel mehr Dinge laufen in
Debug
als nur Ihre Anwendung, die code wie den debug-Symbole erhöhen den Speicherbedarf eines scheinbar kleinen Anwendung.Wenn Sie brauchen, um die Suche nach memory leaks oder hohen Verbrauch (dies ist eine Metrik, die auf Ihre spezielle situation), dann benutzen Sie ein Bewährtes und profiler wie ANTS Profiler.
Und das api war nur das Beispiel von meinem code.
InformationsquelleAutor ethane
Nur ein Tipp: Achten Sie auf eine korrekte Registrierung jeder Anfrage und Dienst in den Systemstart.cs (wo Ihr IoC enthält). 🙂
https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection#service-lifetimes-and-registration-options
InformationsquelleAutor mark333...333...333