Zgodnie z zasadą DRY w ASP.NET

Question

Niedawno zaangażowałem się w klasyczny projekt ASP.NET, który zawiera wiele wartości przechowywanych i odczytywanych z sesji i ciągów zapytań. Może to wyglądać następująco:

Session["someKey"]=someValue; 

A gdzie indziej w kodzie odczytana jest wartość w sesji. Najwyraźniej jest to niezgodne z zasadą DRY, ponieważ literowy ciąg znaków jest rozłożony na całym kodzie. Jednym ze sposobów uniknięcia tego może być przechowywanie wszystkich kluczy jako stałych, do których można się odwoływać wszędzie tam, gdzie istnieje potrzeba odczytu i zapisu w sesji. Ale nie jestem pewien, czy to najlepszy sposób na zrobienie tego. Jak poleciłbym najlepiej sobie z tym poradzić, aby nie naruszać zasady DRY?

Answer 1

utworzyć osobną klasę publiczną, gdzie można zdefiniować stałe, np

public class SessionVars 
{ 
    public const string SOME_KEY = "someKey"; 
    public const string SOME_OTHER_KEY = "someOtherKey"; 
} 

a następnie nigdzie w kodzie można uzyskać dostęp do zmiennych sesji tak:

Session[SessionVars.SOME_KEY]=someValue; 

W ten sposób można uzyskać IntelliSence i inne dzwony i gwizdki.

Answer 2

Wydaje mi się, że za dużo czytasz w SUCHU. Dotyczę więcej rzeczy, które można zawrzeć w funkcji. To znaczy. zamiast powtarzać te same linie piątek w całym miejscu, owinąć te 5 linii w funkcję i wywołać funkcję wszędzie tam, gdzie jej potrzebujesz.

Przykładem jest po prostu ustawienie wartości w słowniku (w tym przypadku obiektem sesji), i to jest najprostszy sposób przechowywania i pobierania w nim obiektów.

Answer 3

Opcjonalnie można umieścić dostęp do tego obiektu sesji w stronę bazy i zawinąć go w nieruchomości:

class BasePage : Page 
{ 
    ... 
    public string MySessionObject 
    { 
     get 
     { 
     if(Session["myKey"] == null) 
      return string.Empty; 
     return Session["myKey"].ToString(); 
     } 
     set 
     { 
      Session["myKey"] = value; 
     } 
    } 
    ... 
} 

Tutaj powtarzamy ciąg myKey ale jest zamknięty w domu. Jeśli chcesz tego uniknąć, utwórz stałą za pomocą klawisza i zastąp ciąg.

Answer 4

nie pamiętam dla życia mnie gdzie ja pokornie ponownie przeznaczona ten kod, ale to bardzo miłe:

using System; 
using System.Web; 

namespace Project.Web.UI.Domain 
{ 
    public abstract class SessionBase<T> where T : class, new() 
    { 
     private static readonly Object _padlock = new Object(); 

     private static string Key 
     { 
      get { return typeof(SessionBase<T>).FullName; } 
     } 

     public static T Current 
     { 
      get 
      { 
       var instance = HttpContext.Current.Session[Key] as T; 

       lock (SessionBase<T>._padlock) 
       { 
        if (instance == null) 
        { 
         HttpContext.Current.Session[Key] 
          = instance 
          = new T(); 
        } 
       } 
       return instance; 
      } 
     } 

     public static void Clear() 
     { 
      var instance = HttpContext.Current.Session[Key] as T; 
      if (instance != null) 
      { 
       lock (SessionBase<T>._padlock) 
       { 
        HttpContext.Current.Session[Key] = null; 
       } 
      } 
     } 
    } 
} 

Ideą dwojakie. Utworzony typ powinien być jedynym potrzebnym typem. Jest to w zasadzie duże, mocno wpisane opakowanie. Więc masz jakiś przedmiot chcesz zachować rozszerzenie informacji:

public class MyClass 
{ 
    public MyClass() 

    public string Blah1 { get; set; } 
} 

Następnie w dół drogi rozszerzyć MyClass i nie chcesz mieć do zapamiętania wszystkich kluczowych wartości, przechowywać je w AppSettings lub zmiennych w Konst Klasy statyczne. Po prostu zdefiniuj, co chcesz przechowywać:

public class MyClassSession : SessionBase<MyClass> 
{ 
} 

A w dowolnym miejscu programu po prostu korzystasz z klasy.

// Any Asp.Net method (webforms or mvc) 
public void SetValueMethod() 
{ 
    MyClassSesssion.Current.Blah1 = "asdf"; 
} 

public string GetValueMethod() 
{ 
    return MyClassSession.Current.Blah1; 
}