Możesz uzyskać dostęp do stanu sesji za pomocą niestandardowego programu obsługi RouteHandler.

// In global.asax
public class MvcApp : System.Web.HttpApplication
{
    public static void RegisterRoutes(RouteCollection routes)
    {
        var route = routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{id}",
            defaults: new { id = RouteParameter.Optional }
        );
        route.RouteHandler = new MyHttpControllerRouteHandler();
    }
}

// Create two new classes
public class MyHttpControllerHandler
    : HttpControllerHandler, IRequiresSessionState
{
    public MyHttpControllerHandler(RouteData routeData) : base(routeData)
    { }
}
public class MyHttpControllerRouteHandler : HttpControllerRouteHandler
{
    protected override IHttpHandler GetHttpHandler(
        RequestContext requestContext)
    {
        return new MyHttpControllerHandler(requestContext.RouteData);
    }
}

// Now Session is visible in your Web API
public class ValuesController : ApiController
{
    public string Get(string input)
    {
        var session = HttpContext.Current.Session;
        if (session != null)
        {
            if (session["Time"] == null)
                session["Time"] = DateTime.Now;
            return "Session Time: " + session["Time"] + input;
        }
        return "Session is not availabe" + input;
    }
}

Znaleziono tutaj: http://techhasnoboundary.blogspot.com/2012/03/mvc-4-web-api-access-session.html

Dlaczego unikać używania sesji w WebAPI?

Wydajność, wydajność, wydajność!

Jest bardzo dobry i często pomijany powód, dla którego w ogóle nie powinieneś używać sesji w WebAPI.

The way ASP.NET działa, gdy sesja jest w użyciu, Aby serializować wszystkie żądania otrzymane od jednego klienta . Teraz nie mówię o serializacji obiektów - ale uruchamianie ich w otrzymanej kolejności i oczekiwanie na zakończenie każdego z nich przed uruchomieniem następnego. To jest aby uniknąć nieprzyjemnych warunków wątku / wyścigu, jeśli po dwa żądania każda próba dostępu do sesji jednocześnie.

Współbieżne żądania i stan sesji

Dostęp do ASP.NET stan sesji jest wyłączne na sesję, co oznacza, że jeśli dwóch różnych użytkowników jednoczesnych żądań, dostęp do każdej osobnej sesji jest przyznawany / align = "left" / Jednakże Jeśli dwa równoległe wnioski są składane dla tej samej sesji (używając tej samej wartości SessionID), pierwsza wniosek otrzymuje wyłączny dostęp do informacji o sesji. Drugi wniosek wykonuje dopiero po zakończeniu pierwszego żądania. (druga sesja może również uzyskać dostęp, jeśli wyłączna blokada informacji jest zwolniona ponieważ pierwsze żądanie przekracza czas blokady.) Jeśli EnableSessionState wartość w dyrektywie @ Page jest ustawiona na ReadOnly, a żądanie informacji o sesji tylko do odczytu nie powoduje wyłączna blokada danych sesji. Jednak tylko do odczytu wnioski o dane sesji mogą nadal czekać na blokadę ustawioną przez odczyt-zapis Prośba o wyczyszczenie danych sesji.

Co to oznacza dla Web API? Jeśli masz aplikację z wieloma żądaniami AJAX, tylko jedna będzie mogła działać na raz. Jeśli masz wolniejsze żądanie, zablokuje ono wszystkie inne od tego klienta, dopóki nie zostanie ukończone. W niektórych zastosowaniach może to prowadzić do bardzo zauważalnie powolnej wydajności.

Więc prawdopodobnie powinieneś użyć MVC controller jeśli absolutnie potrzebujesz czegoś z sesji użytkowników i unikniesz kary za unncesessary performance polegającej na włączeniu go dla WebApi.

Możesz łatwo przetestować to samodzielnie, po prostu umieszczając Thread.Sleep(5000) w metodzie WebAPI i włącz sesję. Uruchom 5 żądań do niego, a ich wykonanie zajmie w sumie 25 sekund. Bez sesji zajmą w sumie nieco ponad 5 sekund.

(to samo rozumowanie dotyczy SignalR).

No masz rację, reszta jest bezpaństwowa. Jeśli używasz sesji, przetwarzanie stanie się stanowe, kolejne żądania będą mogły używać stanu (z sesji).

W celu ponownego nawodnienia sesji, musisz podać klucz do powiązania stanu. W normalnym asp.net aplikacja klucz jest dostarczany za pomocą pliku cookie (cookie-sessions) lub parametru url (cookieless sessions).

Jeśli potrzebujesz sesji forget rest, sesje są nieistotne w projektach opartych na REST. Jeśli potrzebujesz sesji do walidacji, a następnie użyj tokena lub Autoryzuj przez adresy IP.

Zaznacz, jeśli sprawdzisz przykład nerddinner MVC logika jest prawie taka sama.

Wystarczy pobrać plik cookie i ustawić go w bieżącej sesji.

Globalny.asax.cs

public override void Init()
{
    this.AuthenticateRequest += new EventHandler(WebApiApplication_AuthenticateRequest);
    base.Init();
}

void WebApiApplication_AuthenticateRequest(object sender, EventArgs e)
{
    HttpCookie cookie = HttpContext.Current.Request.Cookies[FormsAuthentication.FormsCookieName];
    FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(cookie.Value);

    SampleIdentity id = new SampleIdentity(ticket);
    GenericPrincipal prin = new GenericPrincipal(id, null); 

    HttpContext.Current.User = prin;
}

enter code here

Będziesz musiał zdefiniować klasę "SampleIdentity" , którą możesz wypożyczyć z projektu nerddinner .

Ostatni nie działa, weź ten, u mnie zadziałał.

W WebApiConfig.cs at App_Start

    public static string _WebApiExecutionPath = "api";

    public static void Register(HttpConfiguration config)
    {
        var basicRouteTemplate = string.Format("{0}/{1}", _WebApiExecutionPath, "{controller}");

        // Controller Only
        // To handle routes like `/api/VTRouting`
        config.Routes.MapHttpRoute(
            name: "ControllerOnly",
            routeTemplate: basicRouteTemplate//"{0}/{controller}"
        );

        // Controller with ID
        // To handle routes like `/api/VTRouting/1`
        config.Routes.MapHttpRoute(
            name: "ControllerAndId",
            routeTemplate: string.Format ("{0}/{1}", basicRouteTemplate, "{id}"),
            defaults: null,
            constraints: new { id = @"^\d+$" } // Only integers 
        );

Globalny.asax

protected void Application_PostAuthorizeRequest()
{
  if (IsWebApiRequest())
  {
    HttpContext.Current.SetSessionStateBehavior(SessionStateBehavior.Required);
  }
}

private static bool IsWebApiRequest()
{
  return HttpContext.Current.Request.AppRelativeCurrentExecutionFilePath.StartsWith(_WebApiExecutionPath);
}

Fournd here: http://forums.asp.net/t/1773026.aspx/1

Aby Rozwiązać Problem:

protected void Application_PostAuthorizeRequest()
{
    System.Web.HttpContext.Current.SetSessionStateBehavior(System.Web.SessionState.SessionStateBehavior.Required);
}

In Global.asax.cs

Idąc dalej od odpowiedzi Lachlanba, jeśli twój kontroler ApiController nie znajduje się w określonym katalogu (np. /api), możesz zamiast tego przetestować żądanie za pomocą RouteTable.Trasy.GetRouteData, na przykład:

protected void Application_PostAuthorizeRequest()
    {
        // WebApi SessionState
        var routeData = RouteTable.Routes.GetRouteData(new HttpContextWrapper(HttpContext.Current));
        if (routeData != null && routeData.RouteHandler is HttpControllerRouteHandler)
            HttpContext.Current.SetSessionStateBehavior(SessionStateBehavior.Required);
    }

Miałem ten sam problem w asp.net mvc, naprawiłem to umieszczając tę metodę w moim podstawowym kontrolerze api, od którego wszystkie kontrolery API dziedziczą:

    /// <summary>
    /// Get the session from HttpContext.Current, if that is null try to get it from the Request properties.
    /// </summary>
    /// <returns></returns>
    protected HttpContextWrapper GetHttpContextWrapper()
    {
      HttpContextWrapper httpContextWrapper = null;
      if (HttpContext.Current != null)
      {
        httpContextWrapper = new HttpContextWrapper(HttpContext.Current);
      }
      else if (Request.Properties.ContainsKey("MS_HttpContext"))
      {
        httpContextWrapper = (HttpContextWrapper)Request.Properties["MS_HttpContext"];
      }
      return httpContextWrapper;
    }

Następnie w wywołaniu api, które chcesz uzyskać dostęp do sesji, po prostu wykonaj:

HttpContextWrapper httpContextWrapper = GetHttpContextWrapper();
var someVariableFromSession = httpContextWrapper.Session["SomeSessionValue"];

/// <summary>
/// The following method makes Session available.
/// </summary>
protected void Application_PostAuthorizeRequest()
{
  if (HttpContext.Current.Request.AppRelativeCurrentExecutionFilePath.StartsWith("~/api"))
  {
    HttpContext.Current.SetSessionStateBehavior(SessionStateBehavior.Required);
  }
}

Można również po prostu zrobić własny atrybut filtra, który można trzymaj się wywołań api, które potrzebujesz sesji, a następnie możesz użyć sesji w wywołaniu api, jak zwykle za pośrednictwem HttpContext.Aktualne.Sesja ["SomeValue"]:

  /// <summary>
  /// Filter that gets session context from request if HttpContext.Current is null.
  /// </summary>
  public class RequireSessionAttribute : ActionFilterAttribute
  {
    /// <summary>
    /// Runs before action
    /// </summary>
    /// <param name="actionContext"></param>
    public override void OnActionExecuting(HttpActionContext actionContext)
    {
      if (HttpContext.Current == null)
      {
        if (actionContext.Request.Properties.ContainsKey("MS_HttpContext"))
        {
          HttpContext.Current = ((HttpContextWrapper)actionContext.Request.Properties["MS_HttpContext"]).ApplicationInstance.Context;
        }
      }
    }
  }

Zastosowałem podejście @ LachlanB i rzeczywiście sesja była dostępna, gdy plik cookie sesji był obecny na żądaniu. Brakującą częścią jest sposób, w jaki plik cookie sesji jest wysyłany do klienta po raz pierwszy?

Utworzyłem HttpModule, który nie tylko włącza dostępność HttpSessionState, ale także wysyła plik cookie do klienta po utworzeniu nowej sesji.

public class WebApiSessionModule : IHttpModule
{
    private static readonly string SessionStateCookieName = "ASP.NET_SessionId";

    public void Init(HttpApplication context)
    {
        context.PostAuthorizeRequest += this.OnPostAuthorizeRequest;
        context.PostRequestHandlerExecute += this.PostRequestHandlerExecute;
    }

    public void Dispose()
    {
    }

    protected virtual void OnPostAuthorizeRequest(object sender, EventArgs e)
    {
        HttpContext context = HttpContext.Current;

        if (this.IsWebApiRequest(context))
        {
            context.SetSessionStateBehavior(SessionStateBehavior.Required);
        }
    }

    protected virtual void PostRequestHandlerExecute(object sender, EventArgs e)
    {
        HttpContext context = HttpContext.Current;

        if (this.IsWebApiRequest(context))
        {
            this.AddSessionCookieToResponseIfNeeded(context);
        }
    }

    protected virtual void AddSessionCookieToResponseIfNeeded(HttpContext context)
    {
        HttpSessionState session = context.Session;

        if (session == null)
        {
            // session not available
            return;
        }

        if (!session.IsNewSession)
        {
            // it's safe to assume that the cookie was
            // received as part of the request so there is
            // no need to set it
            return;
        }

        string cookieName = GetSessionCookieName();
        HttpCookie cookie = context.Response.Cookies[cookieName];
        if (cookie == null || cookie.Value != session.SessionID)
        {
            context.Response.Cookies.Remove(cookieName);
            context.Response.Cookies.Add(new HttpCookie(cookieName, session.SessionID));
        }
    }

    protected virtual string GetSessionCookieName()
    {
        var sessionStateSection = (SessionStateSection)ConfigurationManager.GetSection("system.web/sessionState");

        return sessionStateSection != null && !string.IsNullOrWhiteSpace(sessionStateSection.CookieName) ? sessionStateSection.CookieName : SessionStateCookieName;
    }

    protected virtual bool IsWebApiRequest(HttpContext context)
    {
        string requestPath = context.Request.AppRelativeCurrentExecutionFilePath;

        if (requestPath == null)
        {
            return false;
        }

        return requestPath.StartsWith(WebApiConfig.UrlPrefixRelative, StringComparison.InvariantCultureIgnoreCase);
    }
}

Jedna rzecz trzeba wspomnieć w odpowiedzi @LachlanB.

protected void Application_PostAuthorizeRequest()
    {
        if (IsWebApiRequest())
        {
            HttpContext.Current.SetSessionStateBehavior(SessionStateBehavior.Required);
        }
    }

Jeśli pominiesz linię if (IsWebApiRequest())

Cała witryna będzie miała problem z powolnym ładowaniem strony, jeśli Twoja witryna jest mieszana ze stronami formularza internetowego.

Wracając do podstaw dlaczego nie zachować prostoty i zapisać wartość sesji w ukrytej wartości html, aby przekazać ją do API?

Controller

public ActionResult Index()
        {

            Session["Blah"] = 609;

            YourObject yourObject = new YourObject();
            yourObject.SessionValue = int.Parse(Session["Blah"].ToString());

            return View(yourObject);
        }

Cshtml

@model YourObject

@{
    var sessionValue = Model.SessionValue;
}

<input type="hidden" value="@sessionValue" id="hBlah" />

Javascript

$(dokument).ready (function () {

    var sessionValue = $('#hBlah').val();

    alert(sessionValue);

    /* Now call your API with the session variable */}

}