Jak przypisać wartości profilu?

Projekty aplikacji webowych mogą nadal używać obiektu ProfileCommon, ale tylko w czasie wykonywania. Kod dla niego nie jest po prostu generowany w samym projekcie, ale klasa jest generowana przez ASP.Net i jest obecny w czasie wykonywania.

Najprostszym sposobem dotarcia do obiektu jest użycie typu dynamicznego, jak pokazano poniżej.

W Sieci.plik konfiguracyjny deklaruje właściwości profilu:

<profile ...
 <properties>
   <add name="GivenName"/>
   <add name="Surname"/>
 </properties>

Następnie, aby uzyskać dostęp do właściwości:

dynamic profile = ProfileBase.Create(Membership.GetUser().UserName);
string s = profile.GivenName;
profile.Surname = "Smith";

Aby zapisać zmiany w profilu właściwości:

profile.Save();

Powyższe działa dobrze, jeśli wygodnie używasz typów dynamicznych i nie przeszkadza ci brak sprawdzania w czasie kompilacji i intellisense.

Jeśli używasz tego z ASP.Net MVC musisz wykonać dodatkową pracę, jeśli przekażesz obiekt dynamic profile do swoich widoków, ponieważ metody pomocnicze HTML nie grają dobrze z obiektami" modelowymi", które są dynamiczne. Będziesz musiał przypisać właściwości profilu do statycznie wpisanych zmiennych przed przekazaniem ich do helpera HTML metody.

// model is of type dynamic and was passed in from the controller
@Html.TextBox("Surname", model.Surname) <-- this breaks

@{ string sn = model.Surname; }
@Html.TextBox("Surname", sn); <-- will work

Jeśli utworzysz własną klasę profilu, jak opisano powyżej, ASP.Net nadal będzie generować klasę ProfileCommon, ale będzie dziedziczyć z Twojej niestandardowej klasy profilu. Jeśli nie podasz niestandardowego profilu Klasa ProfileCommon dziedziczy z systemu.Www.Profil.ProfileBase.

Jeśli tworzysz własną klasę profilu, upewnij się, że nie określasz właściwości profilu w sieci.plik konfiguracyjny, który został już zadeklarowany w klasie profilu niestandardowego. Jeśli tak ASP.Net spowoduje błąd kompilatora podczas próby wygenerowania klasy ProfileCommon.

Profile mogą być również wykorzystywane w projektach aplikacji internetowych. Właściwości można zdefiniować w Web.konfiguracja w czasie projektowania lub programowo. W Sieci.config:

<profile enabled="true" automaticSaveEnabled="true" defaultProvider="AspNetSqlProfileProvider">
      <providers>
        <clear/>
        <add name="AspNetSqlProfileProvider" type="System.Web.Profile.SqlProfileProvider" connectionStringName="ApplicationServices" applicationName="TestRolesNProfiles"/>
      </providers>
      <properties>
        <add name="FirstName"/>
        <add name="LastName"/>
        <add name ="Street"/>
        <add name="Address2"/>
        <add name="City"/>
        <add name="ZIP"/>
        <add name="HomePhone"/>
        <add name="MobilePhone"/>
        <add name="DOB"/>

      </properties>
    </profile>

Lub programowo, Utwórz sekcję profilu, tworząc instancję ProfileSection i tworząc indywidualne właściwości za pomocą ProfilePropertySettings i ProfilePropertySettingsColletion , z których wszystkie znajdują się w systemie.Www.Przestrzeń Nazw Konfiguracji. Aby skorzystać z tych właściwości profilu, użyj System.Www.Profil.Obiekty ProfileBase. Nie można uzyskać dostępu do właściwości profilu za pomocą profile. składnia jak wspomniano powyżej, ale można to łatwo zrobić poprzez utworzenie instancji ProfileBase i użycie SetPropertyValue("PropertyName ") oraz GetPropertyValue{"PropertyName ") w następujący sposób:

ProfileBase curProfile = ProfileBase.Create("MyName");

Lub aby uzyskać dostęp do profilu bieżącego użytkownika:

ProfileBase curProfile = ProfileBase.Create(System.Web.Security.Membership.GetUser().UserName);



        curProfile.SetPropertyValue("FirstName", this.txtName.Text);
        curProfile.SetPropertyValue("LastName", this.txtLname.Text);
        curProfile.SetPropertyValue("Street", this.txtStreet.Text);
        curProfile.SetPropertyValue("Address2", this.txtAdd2.Text);
        curProfile.SetPropertyValue("ZIP", this.txtZip.Text);
        curProfile.SetPropertyValue("MobilePhone", txtMphone.Text);
        curProfile.SetPropertyValue("HomePhone", txtHphone.Text);
        curProfile.SetPropertyValue("DOB", txtDob.Text);
        curProfile.Save();

Kiedy tworzysz nowy projekt strony internetowej w Visual Studio, obiekt zwrócony z profilu zostanie (automatycznie) wygenerowany dla Ciebie. Podczas tworzenia projektu aplikacji internetowej lub projektu MVC, będziesz musiał zwijać swój własny.

To chyba brzmi trudniej niż jest. Musisz wykonać następujące czynności:

• Utwórz bazę danych używając aspnet_regsql.exe to narzędzie jest instalowane wraz z. NET framework.
• napisz klasę, która wywodzi z ProfileGroupBase lub zainstaluj Web Profile Builder (WPB), który może wygenerować klasę dla Ciebie z definicji w Web.Config. Używam WPB przez jakiś czas i do tej pory zrobił to, czego się od niego oczekuje. Jeśli masz wiele właściwości, korzystanie z WPB może zaoszczędzić sporo czasu.
• Upewnij się, że połączenie z bazą danych jest poprawnie skonfigurowane w Web.Config.
• Teraz możesz utworzyć instancję swojej klasy profilu (w kontrolerze)
• będziesz prawdopodobnie potrzebujesz wartości właściwości profilu w swoich widokach. Lubię przekazywać sam obiekt profilu do widoku (nie pojedyncze właściwości).

Jeśli korzystasz z projektu aplikacji webowej, nie możesz uzyskać dostępu do obiektu Profile w momencie projektowania po wyjęciu z pudełka. Oto narzędzie, które rzekomo robi to za Ciebie: http://weblogs.asp.net/joewrobel/archive/2008/02/03/web-profile-builder-for-web-application-projects.aspx. osobiście, to narzędzie spowodowało błąd w moim projekcie, więc skończyło się na zwijaniu mojej własnej klasy profilu do dziedziczenia z ProfileBase. To nie było trudne do zrobienia w ogóle.

MSDN walkthrough do tworzenia niestandardowej klasy (a. K. a. Joel ' s method):
http://msdn.microsoft.com/en-us/magazine/cc163624.aspx

Też przechodziłem przez ten sam problem. Ale zamiast tworzyć klasę, która dziedziczy z ProfileBase, użyłem HttpContext.

Określ właściwości w web.plik konfiguracyjny w następujący sposób : -

Teraz napisz następujący kod: -

Skompiluj i uruchom kod. Otrzymasz następujące wyjście: -

The Web Profile Builder pracował dla mnie świetnie. Klasa, którą wygenerował, ma w sobie o wiele więcej niż opisała to w poście Joela. Czy jego rzeczywiście potrzebne lub Przydatne Nie wiem.

W każdym razie dla tych, którzy szukają łatwego sposobu generowania klasy, ale nie chcą mieć zewnętrznego narzędzia budowania zależności, zawsze możesz

• Użyj kreatora profili internetowych
• usuń wszystkie ślady!
• używaj generowanej klasy profilu

Lub (untested but may just work)

• stwórz stronę internetową Strona projekt
• utwórz swój element
• przyciągnij wygenerowaną klasę i skopiuj ją na swoją stronę projekt projekt

Jeśli to drugie podejście zadziała, czy ktoś może dać mi znać w przyszłości

Po prostu chcę dodać do odpowiedzi Joela Spolsky ' ego

Zaimplementowałem jego rozwiązanie, działa genialnie btw-Cudos!

Dla każdego, kto chce mieć profil użytkownika, który nie jest zalogowanym użytkownikiem, którego używałem:

Www.config:

  <connectionStrings>
    <clear />
    <add name="LocalSqlConnection" connectionString="Data Source=***;Database=***;User Id=***;Password=***;Initial Catalog=***;Integrated Security=false" providerName="System.Data.SqlClient" />
  </connectionStrings>

I

<profile defaultProvider="SqlProvider" inherits="NameSpace.AccountProfile" enabled="true">
  <providers>
    <clear/>
    <add name="SqlProvider" type="System.Web.Profile.SqlProfileProvider" connectionStringName="LocalSqlConnection"/>
  </providers>

A potem moja klasa niestandardowa:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Profile;
using System.Web.Security;

namespace NameSpace
{
    public class AccountProfile : ProfileBase
    {
        static public AccountProfile CurrentUser
        {
            get
            {
                return (AccountProfile)
                 (ProfileBase.Create(Membership.GetUser().UserName));
            }
        }

        static public AccountProfile GetUser(MembershipUser User)
        {
            return (AccountProfile)
                (ProfileBase.Create(User.UserName));
        }

        /// <summary>
        /// Find user with matching barcode, if no user is found function throws exception
        /// </summary>
        /// <param name="Barcode">The barcode to compare against the user barcode</param>
        /// <returns>The AccountProfile class with matching barcode or null if the user is not found</returns>
        static public AccountProfile GetUser(string Barcode)
        {
            MembershipUserCollection muc = Membership.GetAllUsers();

            foreach (MembershipUser user in muc)
            {
                if (AccountProfile.GetUser(user).Barcode == Barcode)
                {
                    return (AccountProfile)
                        (ProfileBase.Create(user.UserName));
                }
            }
            throw new Exception("User does not exist");
        }

        public bool isOnJob
        {
            get { return (bool)(base["isOnJob"]); }
            set { base["isOnJob"] = value; Save(); }
        }

        public string Barcode
        {
            get { return (string)(base["Barcode"]); }
            set { base["Barcode"] = value; Save(); }
        }
    }
}

Świetny post,

Tylko notka w sieci.config jeśli nie podasz atrybutu inherit w elemencie profilu będziesz musiał określić każdą właściwość profilu indiviudal wewnątrz profilu element w sieci.config jak poniżej

 <properties>
    <clear/>
    <add name="property-name-1" />
    <add name="property-name-2" />
    ..........

 </properties>