Ik weet niet wat ik mis, maar ik heb profieleigenschappen toegevoegd aan het bestand Web.config, maar kan Profile.Itemniet openen in de code of een nieuw profiel maken.
Antwoord 1, autoriteit 100%
Ik had vandaag hetzelfde probleem en heb veel geleerd.
Er zijn twee soorten projecten in Visual Studio: “Websiteprojecten” en “Webtoepassingsprojecten”. Om redenen die mij een compleet raadsel zijn, kan Web Application Projects Profile.niet rechtstreeks gebruiken… de sterk getypeerde klasse wordt niet op magische wijze voor u gegenereerd vanuit het Web.config-bestand, dus u moet rol je eigen.
De voorbeeldcode in MSDN gaat ervan uit dat u een websiteproject gebruikt, en ze vertellen u dat u gewoon een <profile>-sectie moet toevoegen aan uw Web.configen feest door met Profile.property, maar dat werkt niet in webtoepassingsprojecten.
Je hebt twee keuzes om zelf te rollen:
(1) Gebruik de Web Profile Builder. Dit is een aangepaste tool die u toevoegt aan Visual Studio en die automatisch het profielobject genereert dat u nodig hebt op basis van uw definitie in Web.config.
Ik heb ervoor gekozen om dit niet te doen, omdat ik niet wilde dat mijn code afhankelijk was van deze extra tool om te compileren, wat problemen had kunnen veroorzaken voor iemand anders later toen ze probeerden mijn code te bouwen zonder te beseffen dat ze die nodig hadden deze tool.
(2) Maak je eigen klasse die is afgeleid van ProfileBaseom je aangepaste profiel te vertegenwoordigen. Dit is makkelijker dan het lijkt. Hier is een heel erg eenvoudig voorbeeld dat een “FullName” string-profielveld toevoegt:
In uw web.config:
<profile defaultProvider="SqlProvider" inherits="YourNamespace.AccountProfile">
<providers>
<clear />
<add name="SqlProvider"
type="System.Web.Profile.SqlProfileProvider"
connectionStringName="sqlServerMembership" />
</providers>
</profile>
In een bestand met de naam 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
}
}
Een profielwaarde instellen:
AccountProfile.CurrentUser.FullName = "Snoopy";
Een profielwaarde krijgen
string x = AccountProfile.CurrentUser.FullName;
Antwoord 2, autoriteit 9%
Webtoepassingsprojecten kunnen het ProfileCommon-object nog steeds gebruiken, maar alleen tijdens runtime. De code ervoor wordt alleen niet in het project zelf gegenereerd, maar de klasse wordt gegenereerd door ASP.Net en is aanwezig tijdens runtime.
De eenvoudigste manier om bij het object te komen, is door een dynamisch type te gebruiken, zoals hieronder wordt gedemonstreerd.
Declareer in het bestand Web.config de profieleigenschappen:
<profile ...
<properties>
<add name="GivenName"/>
<add name="Surname"/>
</properties>
Vervolgens om toegang te krijgen tot de eigenschappen:
dynamic profile = ProfileBase.Create(Membership.GetUser().UserName);
string s = profile.GivenName;
profile.Surname = "Smith";
Om wijzigingen in profieleigenschappen op te slaan:
profile.Save();
Het bovenstaande werkt prima als je vertrouwd bent met het gebruik van dynamische typen en het gebrek aan compile-time-controle en intellisense niet erg vindt.
Als u dit met ASP.Net MVC gebruikt, moet u wat extra werk doen als u het dynamische profielobject doorgeeft aan uw weergaven, aangezien de HTML-hulpmethoden niet goed werken met dynamische “model”-objecten. U moet profieleigenschappen toewijzen aan statisch getypte variabelen voordat u ze doorgeeft aan HTML-hulpmethoden.
// 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
Als u een aangepaste profielklasse maakt, zoals Joel hierboven beschreef, zal ASP.Net nog steeds de ProfileCommon-klasse genereren, maar deze zal overnemen van uw aangepaste profielklasse. Als u geen aangepaste profielklasse opgeeft, neemt ProfileCommon over van System.Web.Profile.ProfileBase.
Als u uw eigen profielklasse aanmaakt, zorg er dan voor dat u geen profieleigenschappen opgeeft in het Web.config-bestand dat u al hebt gedeclareerd in uw aangepaste profielklasse. Als u dit doet, geeft ASP.Net een compilerfout wanneer het probeert de ProfileCommon-klasse te genereren.
Antwoord 3, autoriteit 7%
Profiel kan ook worden gebruikt in webtoepassingsprojecten.
De eigenschappen kunnen tijdens het ontwerp of programmatisch in Web.config worden gedefinieerd. 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>
of Programmatisch, maak de profielsectie door een ProfileSectionte instantiëren en individuele eigenschappen te maken met behulp van ProfilePropertySettingsen ProfilePropertySettingsColletion, die allemaal in Systeem staan .Web.configuratie naamruimte.
Gebruik System.Web.Profile.ProfileBase Objects om die eigenschappen van het profiel te gebruiken. De profieleigenschappen zijn niet toegankelijk met de profile.-syntaxis zoals hierboven vermeld, maar kan eenvoudig worden gedaan door een ProfileBase te instantiëren en SetPropertyValue(“PropertyNamete gebruiken) “) en GetPropertyValue{“PropertyName“) als volgt:
ProfileBase curProfile = ProfileBase.Create("MyName");
of om toegang te krijgen tot het profiel van de huidige gebruiker:
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();
Antwoord 4, autoriteit 4%
Wanneer u een nieuw websiteproject maakt in Visual Studio, wordt het object dat wordt geretourneerd uit Profiel (automatisch) voor u gegenereerd. Wanneer u een webtoepassingsproject of een MVC-project maakt, moet u uw eigen project maken.
Dit klinkt waarschijnlijk moeilijker dan het is. U moet het volgende doen:
- Maak een database met aspnet_regsql.exeDeze tool wordt samen met het .NET-framework geïnstalleerd.
- Schrijf een klasse die is afgeleid van ProfileGroupBase of installeer de Web Profile Builder (WPB) die de klasse voor u kan genereren op basis van de definitie in Web.Config. Ik gebruik WPB al een tijdje en tot nu toe doet het wat er van verwacht wordt. Als je veel eigendommen hebt, kan het gebruik van WPB behoorlijk wat tijd besparen.
- Zorg ervoor dat de verbinding met de database correct is geconfigureerd in Web.Config.
- Nu bent u klaar om een instantie van uw profielklasse te maken (in de controller)
- U hebt waarschijnlijk de profieleigenschapwaarden nodig in uw weergaven. Ik geef het profielobject zelf graag door aan de weergave (geen individuele eigenschappen).
Antwoord 5, autoriteit 2%
Als u een webtoepassingsproject gebruikt, heeft u geen toegang tot het Profile-object tijdens de ontwerpfase. Hier is een hulpprogramma dat het zogenaamd voor u doet: http://weblogs.asp.net/joewrobel/archive/2008/02/03/web-profile-builder-for-web-application-projects.aspx. Persoonlijk veroorzaakte dat hulpprogramma een fout in mijn project, dus ik heb uiteindelijk mijn eigen profielklasse gegooid om te erven van ProfileBase. Het was helemaal niet moeilijk om te doen.
Antwoord 6
MSDN-overzicht voor het maken van een aangepaste klasse (ook bekend als de methode van Joel):
http://msdn.microsoft.com/en-us/magazine/cc163624. aspx
Antwoord 7
Ik liep ook tegen hetzelfde probleem aan. Maar in plaats van een klasse te maken die erft van ProfileBase, heb ik de HttpContext gebruikt.
Geef de eigenschappen als volgt op in het bestand web.config: –
Schrijf nu de volgende code: –
Compileer en voer de code uit. U krijgt de volgende uitvoer: –
Antwoord 8
De Web Profile Builderwerkte prima voor mij. De klasse die het heeft gegenereerd, bevat veel meer dan zoals beschreven in de post van Joel. Of het echt nodig of nuttig is, weet ik niet.
Hoe dan ook, voor degenen die op zoek zijn naar een gemakkelijke manier om de klasse te genereren, maar geen afhankelijkheid van een externe buildtool willen hebben, kan dat altijd
- gebruik de webprofielbouwer
- wis alle sporen ervan!
- blijf de gegenereerde profielklasse gebruiken
OF (niet getest maar werkt misschien gewoon)
- maak een sitewebproject
- maak je element
- maak de gegenereerde klasse vast en kopieer deze naar uw web project-project
Als deze tweede aanpak werkt, kan iemand me dat dan laten weten voor toekomstig gebruik
Antwoord 9
Ik wil alleen iets toevoegen aan het antwoord van Joel Spolsky
Ik heb zijn oplossing geïmplementeerd en werkte briljant trouwens – Cudos!
Voor iedereen die een gebruikersprofiel wil krijgen dat niet de ingelogde gebruiker is die ik heb gebruikt:
web.config:
<connectionStrings>
<clear />
<add name="LocalSqlConnection" connectionString="Data Source=***;Database=***;User Id=***;Password=***;Initial Catalog=***;Integrated Security=false" providerName="System.Data.SqlClient" />
</connectionStrings>
en
<profile defaultProvider="SqlProvider" inherits="NameSpace.AccountProfile" enabled="true">
<providers>
<clear/>
<add name="SqlProvider" type="System.Web.Profile.SqlProfileProvider" connectionStringName="LocalSqlConnection"/>
</providers>
En dan mijn aangepaste les:
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(); }
}
}
}
Werkt als een tierelier…
Antwoord 10
Geweldige post,
Even een opmerking over de web.config
als u het inherit-attribuut niet opgeeft in het profielelement
u moet elke individuele profieleigenschap binnen het profiel specificeren
element op de web.config zoals hieronder
<properties>
<clear/>
<add name="property-name-1" />
<add name="property-name-2" />
..........
</properties>