Performance von Stringliterale vs Konstanten für Session [...] Dictionary-Schlüssel

Question

Session [Konstante] vs Session [ "String Literal"] Leistung

Ich bin Abrufen benutzerspezifischen Daten wie ViewData["CartItems"] = Session["CartItems"]; mit einem Stringliteral für Schlüssel bei jeder Anfrage. Soll ich Konstanten für diese verwenden?

Wenn ja, wie soll ich mich über häufig verwendete Stringliterale Implementierung und wird die Leistung erheblich auf einem stark frequentierten Standort beeinflussen?

---

Verwandte Frage geht nicht auf ASP.NET MVC oder Session.

Answer 1

Der Grund Konstanten zu verwenden, hat mit Wartbarkeit zu tun, nicht die Leistung. Die Leistung ist etwa die gleiche oder so.

Mit einem String-Literal, kann man nie sagen, ob es das gleiche wie eine andere Zeichenfolge ist wörtliche absichtlich oder durch Zufall, so dass, wenn es an der Zeit eine ändern, können Sie nicht wissen, welche anderen zu ändern. Aber wenn man die Werte in Konstanten haben, die Sie gerade die Änderung an einem Ort machen.

Bad:

ViewData["username"] = Session["username"];

Gut:

const UserNameSessionKey = "username";
const UserNameViewDataKey = "username";

ViewData[UserNameViewDataKey] = Session[UserNameSessionkey];

Nun stellen Sie den Wert des Sitzungsschlüssels zu „Username“ zu ändern, ohne zu wollen es für jeden Bildschirmtextsystem Schlüssel ändern ...

Answer 2

Verwenden Sie die Konstante, da der Compiler gibt Ihnen einen Fehler, wenn Sie es falsch eingeben, während falsch geschriebene Strings werden Ihnen nur wackelig Bugs geben.

Der Performance-Unterschied wahrscheinlich so klein sein, wird es sehr schwierig sein würde, zu messen.

Answer 3

Lets geht weiter mit Wartbarkeit. Ich werde meine andere Antwort über die Verwendung von Session zitieren:

Lassen Sie uns sagen wir dem Warenkorb ist Session unserer ASP.NET MVC-Anwendung gespeichert werden soll. Es wird in Session["ShoppingCart"] gespeichert werden, aber wir wollen einfach, stark typisierten Zugriff und hohe Testbarkeit:

Zuerst definieren wir Schnittstelle:

public interface ISessionWrapper
{
    List<CartItem> ShoppingCart { get; set; }
}

Dann machen wir Httpcontext Umsetzung:

public class HttpContextSessionWrapper : ISessionWrapper
{
    private T GetFromSession<T>(string key)
    {
        return (T) HttpContext.Current.Session[key];
    }

    private void SetInSession(string key, object value)
    {
        HttpContext.Current.Session[key] = value;
    }

    public List<CartItem> ShoppingCart
    {
        get { return GetFromSession<List<CartItem>>("ShoppingCart"); }
        set { SetInSession("ShoppingCart", value); }
    }
}

GetFromSession und SetInSession sind Hilfsmethode, die Daten in Session zu erleichtern nehmen und einstellen. Sie können leicht den Zugriff auf andere Felder in Session wieder verwendet werden.

Dann definieren wir unsere Basis-Controller (für ASP.NET MVC):

public class BaseController : Controller
{
    public ISessionWrapper SessionWrapper { get; set; }

    public BaseController()
    {
        SessionWrapper = new HttpContextSessionWrapper();
    }
}

Wenn Sie Session außerhalb Controller verwenden möchten, die Sie gerade erstellen oder Inject neue HttpContextSessionWrapper ().

Sie können SessionWrapper mit ISessionWrapper Mock in Controller-Tests ersetzen, so dass es nicht abhängig ist mehr auf Httpcontext. Session ist auch einfach zu bedienen, denn anstatt (List<CartItem>)Session["ShoppingCart"] aufzurufen, Sie SessionWrapper.ShoppingCart nennen. Es sieht besser aus, ist es nicht?

Wenn Sie Modellklasse nicht für Ansicht verwenden und ich denke, mit Modellklasse besser ist, können Sie das gleiche tun mit Viewdata:

public interface IViewDataWrapper
{
    List<CartItem> ShoppingCart { get; set; }
}

public class ViewDataWrapper : IViewDataWrapper
{
}

public class BaseController : Controller
{
    public IViewDataWrapper ViewDataWrapper { get; set; }

    public BaseController()
    {
        IViewDataWrapper = new ViewDataWrapper();
    }
}

Und dann einfach in der Steuerung:

ViewDataWrapper.ShoppingCart = SessionWrapper.ShoppingCart 

oder, wenn Sie sich entscheiden, nicht Viewdata und spezifisches Modell zu verwenden:

Model.ShoppingCart = SessionWrapper.ShoppingCart

Und einfach im Blick (wenn Sie für die Ansicht Basisklasse definieren und einführen diese Schnittstelle):

<%= ViewDataWrapper.ShoppingCart %>

oder

<%= Model.ShoppingCart %>

No Strings vertippt, stark typisiert, gut aussehende.

Answer 4

Nur eine kurze Notiz, aber viele der besseren Beispiele haben eine Klasse von SessionKeys String-Konstanten enthält. Dies hilft auch Unit Testing, wie Sie die Konstanten in Ihrer Unit-Tests aufrufen können, wo nötig.

z. (Nur eine Taste, aber offensichtlich können Sie fügen Sie mehr

public class SessionKeys
{
    public const string UserDto = "UserDto";
}

als solche verwendet (ich verwende SessionStateWrapper)

UserDto userDto = _sessionStateWrapper.GetItem(SessionKeys.UserDto) as UserDto;

Answer 5

Nach diesem Benchmark von der Länge der Dictionary-Schlüssel, kürzere Schlüssel sind schneller. Zitat hier:

Wörterbuch String Schlüssellänge Benchmark in C #

Sind kürzere Lookup-Tasten deutlich schneller? Als Schlüssel kürzer werden, Lookup-Zeit wird schneller:

• Key A - 20 Zeichen: 4436 ms [langsamste]
• Key B - 10 Zeichen: 2010 ms
• Key C - 5 Zeichen: 1749 ms
• Key D - 2 Zeichen: 1575 ms [schnellste]

Dabei gilt:

• Key A = "01234567890123456789";
• Key B = "0123456789";
• Key C = "01234";
• Key D = "01";