it-swarm.com.de

Wie weise ich Profilwerte zu?

Ich weiß nicht, was ich vermisse, aber ich habe der Datei Web.config Profileigenschaften hinzugefügt, kann aber nicht auf Profile zugreifen .Item im Code oder ein neues Profil erstellen.

110
zsharp

Ich hatte heute das gleiche Problem und habe viel gelernt.

In Visual Studio gibt es zwei Arten von Projekten: "Websiteprojekte" und "Webanwendungsprojekte". Aus Gründen, die für mich völlig rätselhaft sind, können Webanwendungsprojekte das Profil nicht direkt verwenden. ... Die stark typisierte Klasse wird nicht auf magische Weise für Sie generiert aus der Datei Web.config, so müssen Sie Ihre eigenen rollen.

In dem Beispielcode in MSDN wird davon ausgegangen, dass Sie ein Websiteprojekt verwenden, und es wird Ihnen lediglich empfohlen, einen Abschnitt <profile> Zu Ihrem Abschnitt Web.config Hinzuzufügen und mit Profile.zu feiern. -property, aber das funktioniert in Webanwendungsprojekten nicht.

Sie haben zwei Möglichkeiten, Ihre eigenen zu würfeln:

(1) Verwenden Sie den Web Profile Builder . Dies ist ein benutzerdefiniertes Tool, das Sie zu Visual Studio hinzufügen und das das benötigte Profilobjekt automatisch aus Ihrer Definition in Web.config generiert.

Ich habe mich dagegen entschieden, weil ich nicht wollte, dass mein Code von diesem zusätzlichen Tool zum Kompilieren abhängt. Dies hätte später zu Problemen für andere führen können, als sie versuchten, meinen Code zu erstellen, ohne zu bemerken, dass sie dieses Tool benötigten.

(2) Erstellen Sie eine eigene Klasse, die von ProfileBase abgeleitet ist, um Ihr benutzerdefiniertes Profil darzustellen. Das ist einfacher als es scheint. Hier ist ein sehr sehr einfaches Beispiel, das ein String-Profilfeld "FullName" hinzufügt:

In Ihrer web.config:

<profile defaultProvider="SqlProvider" inherits="YourNamespace.AccountProfile">

<providers>
     <clear />
     <add name="SqlProvider"
          type="System.Web.Profile.SqlProfileProvider"
          connectionStringName="sqlServerMembership" />
</providers>

</profile>

In einer Datei namens AccountProfile.cs:

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

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

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

        // add additional properties here
    }
}

So legen Sie einen Profilwert fest:

AccountProfile.CurrentUser.FullName = "Snoopy";

Um einen Profilwert zu erhalten

string x = AccountProfile.CurrentUser.FullName;
178
Joel Spolsky

Webanwendungsprojekte können das ProfileCommon-Objekt weiterhin verwenden, jedoch nur zur Laufzeit. Der Code dafür wird nur nicht im Projekt selbst generiert, sondern die Klasse wird von ASP.Net generiert und ist zur Laufzeit vorhanden.

Der einfachste Weg, an ein Objekt zu gelangen, ist die Verwendung eines dynamischen Typs (siehe unten).

Deklarieren Sie in der Datei Web.config die Profileigenschaften:

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

Dann, um auf die Eigenschaften zuzugreifen:

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

So speichern Sie Änderungen an den Profileigenschaften:

profile.Save();

Das oben Genannte funktioniert einwandfrei, wenn Sie mit der Verwendung dynamischer Typen vertraut sind und die fehlende Überprüfung der Kompilierungszeit und Intellisense nicht stören.

Wenn Sie dies mit ASP.Net MVC verwenden, müssen Sie einige zusätzliche Arbeiten ausführen, wenn Sie das dynamische Profilobjekt an Ihre Ansichten übergeben, da die HTML-Hilfsmethoden mit "Modell" -Objekten, die dynamisch sind, nicht gut funktionieren. Sie müssen statisch typisierten Variablen Profileigenschaften zuweisen, bevor Sie sie an HTML-Hilfsmethoden übergeben können.

// 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

Wenn Sie eine benutzerdefinierte Profilklasse wie Joel oben beschrieben erstellen, generiert ASP.Net weiterhin die ProfileCommon-Klasse, übernimmt diese jedoch von Ihrer benutzerdefinierten Profilklasse. Wenn Sie keine benutzerdefinierte Profilklasse angeben, wird ProfileCommon von System.Web.Profile.ProfileBase erben.

Wenn Sie eine eigene Profilklasse erstellen, stellen Sie sicher, dass Sie in der Datei Web.config, die Sie bereits in Ihrer benutzerdefinierten Profilklasse deklariert haben, keine Profileigenschaften angeben. Wenn Sie dies tun, gibt ASP.Net einen Compilerfehler aus, wenn versucht wird, die ProfileCommon-Klasse zu generieren.

17
colivier

Das Profil kann auch in Webanwendungsprojekten verwendet werden. Die Eigenschaften können zur Entwurfszeit oder programmgesteuert in der Datei "Web.config" definiert werden. In Web.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>

oder Erstellen Sie programmgesteuert den Profilabschnitt, indem Sie ein ProfileSection instanziieren und einzelne Eigenschaften mit ProfilePropertySettings und ProfilePropertySettingsColletion erstellen, die sich alle in System.Web befinden. Konfigurations-Namespace. Verwenden Sie System.Web.Profile.ProfileBase Objects, um diese Eigenschaften des Profils zu verwenden. Auf die Profileigenschaften kann nicht wie oben erwähnt mit der Syntax profile. zugegriffen werden. Dies kann jedoch einfach durch Instanziieren einer ProfileBase und Verwenden von SetPropertyValue (" PropertyName ") und GetPropertyValue {" PropertyName ") wie folgt:

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

oder um auf das Profil des aktuellen Benutzers zuzugreifen:

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();
13

Wenn Sie ein neues Websiteprojekt in Visual Studio erstellen, wird das von Profile zurückgegebene Objekt (automatisch) für Sie generiert. Wenn Sie ein Webanwendungsprojekt oder ein MVC-Projekt erstellen, müssen Sie Ihre eigenen erstellen.

Das klingt wahrscheinlich schwieriger als es ist. Sie müssen Folgendes tun:

  • Erstellen Sie eine Datenbank mit aspnet_regsql.exe Dieses Tool wird zusammen mit .NET Framework installiert.
  • Schreiben Sie eine Klasse, die von ProfileGroupBase abgeleitet ist, oder installieren Sie den Web Profile Builder (WPB), der die Klasse aus der Definition in Web.Config für Sie generieren kann. Ich benutze WPB seit einer Weile und bis jetzt hat es getan, was von ihm erwartet wird. Wenn Sie viele Eigenschaften haben, kann die Verwendung von WPB viel Zeit sparen.
  • Stellen Sie sicher, dass die Verbindung zur Datenbank in Web.Config ordnungsgemäß konfiguriert ist.
  • Jetzt können Sie eine Instanz Ihrer Profilklasse (im Controller) erstellen.
  • Sie benötigen wahrscheinlich die Profileigenschaftswerte in Ihren Ansichten. Ich mag es, das Profilobjekt selbst an die Ansicht weiterzugeben (nicht einzelne Eigenschaften).
8

Wenn Sie ein Webanwendungsprojekt verwenden, können Sie zur Entwurfszeit nicht sofort auf das Profilobjekt zugreifen. Hier ist ein Dienstprogramm, das dies angeblich für Sie erledigt: http://weblogs.asp.net/joewrobel/archive/2008/02/03/web-profile-builder-for-web-application-projects.aspx . Persönlich verursachte dieses Dienstprogramm einen Fehler in meinem Projekt, sodass ich meine eigene Profilklasse rollte, um von ProfileBase zu erben. Es war überhaupt nicht schwer zu tun.

3
nshaw

MSDN-exemplarische Vorgehensweise zum Erstellen einer benutzerdefinierten Klasse (a.k.a. Joels Methode):
http://msdn.Microsoft.com/en-us/magazine/cc163624.aspx

2
Even Mien

Ich lief auch durch das gleiche Problem. Aber anstatt eine Klasse zu erstellen, die von ProfileBase erbt, habe ich den HttpContext verwendet.

Geben Sie die Eigenschaften in der Datei web.config wie folgt an: ProfilePropertyWeb.config

Schreiben Sie jetzt den folgenden Code: -

Code Behind Profile Properties

Kompilieren Sie den Code und führen Sie ihn aus. Sie erhalten folgende Ausgabe: -

Output

2
Anil Purswani

Ich möchte nur Joel Spolskys Antwort hinzufügen

Ich habe seine Lösung implementiert und dabei hervorragend gearbeitet - Cudos!

Für alle, die ein Benutzerprofil erhalten möchten, das nicht der angemeldete Benutzer ist, den ich verwendet habe:

web.config:

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

und

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

Und dann meine benutzerdefinierte Klasse:

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(); }
        }
    }
}

Klappt wunderbar...

1
Kickass

Der Web Profile Builder hat bei mir hervorragend funktioniert. Die Klasse, die sie generiert hat, enthält viel mehr als in Joels Beitrag beschrieben. Ob es tatsächlich gebraucht oder nützlich ist, weiß ich nicht.

Auf jeden Fall für diejenigen, die nach einer einfachen Möglichkeit suchen, die Klasse zu generieren, aber keine Abhängigkeit von einem externen Build-Tool haben möchten, die Sie immer haben können

  • verwenden Sie den Webprofil-Generator
  • lösche alle Spuren davon!
  • verwenden Sie weiterhin die generierte Profilklasse

ODER (ungetestet, kann aber funktionieren)

  • erstelle ein Web site Projekt
  • erschaffe dein Element
  • fang die generierte Klasse und kopiere sie in dein Web Projekt Projekt

wenn dieser zweite Ansatz funktioniert, kann mich jemand zum späteren Nachschlagen informieren

1
Simon_Weaver

Guter Eintrag,

Nur ein Hinweis in der Datei web.config, wenn Sie das Attribut inherit im Profilelement nicht angeben, müssen Sie jede einzelne Profileigenschaft im Profilelement in der Datei web.config wie folgt angeben

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

 </properties>
0
indy