Weblog Jan V

Go Search
Home
  
Sign In

Systeem account kan geen workflow starten

Na het oplossen van het probleem dat in de vorige post wordt beschreven, wist een collega van mij te vertellen dat dit wellicht te maken kon hebben met het KB artikel 947284 (http://support.microsoft.com/kb/947284).

Hier staat namelijk dat er vanaf Servicepack 1 van Sharepoint een wijziging is geweest in het security model. Het Systeem-account mag namelijk niet meer 'declaratieve' workflows opstarten. Wat 'declaratief' in deze context betekend weet ik niet, maar het lijkt er dus op dat het Systeem account helemaal geen workflows meer op mag starten.

Wanneer je code uitvoert met RunWithElevatedPrivileges, dan wordt dit onder het Systeem-account uitgevoerd, omdat dat account alle rechten zou moeten hebben op de web applicatie.

Dit had ik dus ook in mijn stuk code gedaan. Om er zeker van te zijn ben ik even ingelogd als het Application Pool account op m'n Sharepoint site. Als naam stond hier inderdaad dat ik het Systeemaccount was.

Het is dus zeker een nuttig KB om te kennen bij het schrijven van code dat afhankelijk is van workflows.

Sowieso is het handig om de best-practices te kennen voor het inrichten en configureren van een Sharepoint omgeving. Op zich wist ik namelijk wel dat deze specifieke omgeving niet echt best-practice was, maar had niet gedacht dat zoiets eenvoudigs als het starten van een workflow dan niet meer zou gaan werken.

Automatisch workflow starten bij aanmaken item via code

Enige tijd geleden moest ik iets maken voor een klant dat vanuit een 'gewone' ASP.NET pagina een item aanmaakte in een Sharepoint lijst. Op zich geen probleem, zeker niet omdat er in dezelfde application pool werd gewerkt, waardoor er gewoon gebruik gemaakt kon worden van de RunWithElevatedPrivileges die Sharepoint biedt.

Dit had ik dan ook al snel voor elkaar, maar bij het testen bleek dat de workflow van de lijst niet automatisch werd gestart. Aan de lijst hing namelijk een workflow die automatisch zou moeten starten wanneer er een nieuw item in de lijst wordt aangemaakt.

Na wat zoeken ben ik er achter gekomen dat dit 'normaal' gedrag is en er een work-around voor is, namelijk door de workflow ook zelf via code op te starten. Als je dit weet is dat op zich prima, maar ook dat levert een foutmelding op. De melding was (vrij vertaald): 'Failed to start (retrying)'. Enkele minuten later start de workflow alsnog. Wat wel vervelend is, is dat de gebruiker dit niet kan zien, omdat de status continu hetzelfde blijft, totdat de workflow is beeindigd.

Zelf kan ik hier prima mee leven, zeker omdat ik geen alternatief had.

Vandaag kreeg ik de melding dat er nog iets anders mis ging in het formulier. Na deze melding al vrij snel opgelost te kunnen hebben, heb ik toch even verder gekeken naar dit bovenstaande probleem. Na even zoeken kwam ik langs een post op het MSDN forum waarop staat dat je de workflow ook via de Sharepoint webservices kunt gaan opstarten. Logisch, maar had niet verwacht dat dat een oplossing zou zijn.

Als PoC heb ik de code dus omgeschreven om gebruik te maken van de Sharepoint webservice, gemixed met het object model. Tijdens het doorlopen van de code zag ik dat alles nu wel vlekkeloos werkt.

Wat ik nu gedaan heb is het volgende (versimpeld voorbeeld):

private bool StartWorkflow(SPList list, SPListItem listItem, SPWorkflowAssociation wf)

{

bool started = false;

      WorkflowService.Workflow workflowService = new WorkflowService.Workflow();

workflowService.Url = webserviceLink;

workflowService.UseDefaultCredentials = true;

workflowService.Credentials = new NetworkCredential(ADMIN_USERNAME, ADMIN_PASSWORD, ADMIN_DOMAIN);

workflowService.PreAuthenticate = true;

 

XmlDocument workflowParameters = new XmlDocument();

workflowParameters.LoadXml(wf.AssociationData);

workflowService.StartWorkflow(String.Format("http://testsite/{0}", listItem.Url), wf.Id, workflowParameters);

return started;

}

 

Op deze manier maak je dus gebruik van de webservice (WorkflowService = vti_bin/Workflow.asmx). Het is nog niet getest door ons testteam en staat nog niet in productie, maar ziet er toch naar uit dat dit het 'probleem' heeft opgelost van de vage melding. Nu krijg ik alleen maar een juiste status te zien van de workflow en hoef ik ook niet 5 minuten te wachten voordat de workflow opstart (Sharepoint timer).

Nog steeds geen echte support voor GUID identity velden in EF4.0

In m'n database maak ik gebruik van een idenity veld dat bestaat uit een Guid. Deze guid wordt automatisch gegenereerd binnen SQL Server door middel van de newsequentialid() functie (dit kan uiteraard ook met newid()). Dit betekend dus dat ik in m'n code niet een guid hoef aan te maken, omdat SQL dit al zelf doet. In de op te slaan entity vul ik het ID veld dus ook niet.

Nadat het insert commando is uitgevoerd verwachtte ik dat het ID veld zou worden gevuld met de nieuw aangemaakte guid, maar niets is minder waar. Het blijft een Guid.Empty (00000000-0000-0000-0000-000000000000). In het EF1.0 werkte dit inderdaad niet, daar was helemaal geen support voor Guid identity velden. Er was echter beloofd om dit wel op te lossen in het EF4.0. Na een kleine zoektocht kom ik op allerlei pagina's en sites die het hebben over EF1.0 en Linq-to-Sql, iets waar ik in het verleden ook al dit probleem heb gehad.

Met de ervaring die ik uit het verleden had, heb ik ook al even zelf zitten klikken en zag dat de StoreGeneratedPattern op None stond. Deze heb ik op Identity en op Computed gezet. Beide keren was dit niet de oplossing.

Uiteindelijk ben ik op een post van Lee Dumond uitgekomen: http://leedumond.com/blog/using-a-guid-as-an-entitykey-in-entity-framework-4/

Hier loopt hij tegen hetzelfde probleem aan als mij.

Hij heeft hier de oplossing beschreven, namelijk dat je zelf, handmatig, de XML van het edmx-bestand moet aanpassen en dan bij het veld instellen dat dit een Identity veld is.

In de edmx:StorageModels moet je zelf bij het juiste veld aangeven dat deze automatisch wordt aangemaakt:

<edmx:StorageModels>

……

    <EntityContainer Name="ProjectModelStoreContainer">

        <EntitySet Name="Item" EntityType="ProjectModel.Store.Item" store:Type="Tables" Schema="dbo" />

        <EntitySet Name="ItemType" EntityType="ProjectModel.Store.ItemType" store:Type="Tables" Schema="dbo" />

……

Dit heeft als resultaat dat het veld in het model ook echt een Identity veld wordt. Normaal kun je dit namelijk niet aanpassen in de properties:

Wel blijft het raar dat dit niet automatisch goed wordt geregeld. Hopelijk wordt dit wel opgelost in een servicepack of EF5.0.

Entity Framework in een N-Tier en N-layered design

Momenteel ben ik met een project bezig dat met 2 tiers werkt (de database even niet meegerekend). Er is een presentatie laag (MVP) en deze staat in verbinding met een WCF service, de 2e tier. Deze 2e tier heeft dus een service laag, maar ook een business- (BL) en een data access laag (DAL). Dit is tegenwoordig een redelijk standaard design.

Omdat ik het Entity Framework wil gebruiken (http://weblogjanv/Lists/Posts/Post.aspx?ID=186) zal alleen de DAL toegang moeten hebben tot het Model. De verschillende Entities worden wel in alle projecten gelinkt (service layer, busines layer en data access layer).

Het design heb ik al een tijd goed werkend, echter toen ik het geheel wilde gaan testen liep ik tegen problemen aan. De eerste fout die ik tegen kwam was de volgende:

"ArgumentException: The specified named connection is either not found in the configuration, not intented tob e used with EntityClient provider, or not valid"

Dit was al snel opgelost door de connectiestring in de web.config van de service te plaatsen.

Nadat ik dat had gedaan kwam er een vervelende fout naar voren, namelijk:

"MetadataException: Unable to load the specified metadata resource.".

Er is hier veel over te vinden op het internet en komt er op neer dat de metadata van de edmx niet in de dll zijn meegenomen, of dat de referenties in de connectiestring niet correct zijn.

Een van de oplossingen is dan om in dit gedeelte van de connectiestring:

metadata=res://*/Model.csdl|res://*/Model.ssdl|res://*/Model.msl

de * tekens te vervangen met de naam van de dll, dan zou er zoiets moeten komen te staan:

metadata=res://ModelProject/Model.csdl|res://ModelProject/Model.ssdl|res://ModelProject/Model.msl

De reden om dit te doen, is omdat de applicatie blijkbaar moeite kan hebben met het vinden van de benodigde bestanden binnen de dll's.

Nog een oplossing zou kunnen zijn om de Metadata Artifact Processing te wijzigen.

Deze staat normaal op Embed in Output Assembly, maar zou dan op Copy to Output Directory gezet kunnen worden. De aangemaakte bestanden (csdl, ssdl en msl) moeten dan handmatig worden gekopieerd naar de root of bin map van de service, afhankelijk van wat je in de web.config zet.

Beide opties boden mij geen oplossing. Tijdens het zoeken naar een oplossing voor m'n probleem merkte ik op dat de dll van het Model project niet in m'n bin map werd geplaatst. Dan is het natuurlijk logisch dat de metadata niet gevonden kan worden, aangezien die ook niet aanwezig is.

Na veel zoeken heb ik nergens een antwoord kunnen vinden dat mij zou helpen. Overal werd in de service ook gelijk een verbinding gemaakt naar het Model, waardoor alles goed gaat. Vandaag had ik ineens een helder moment. Het kan natuurlijk zijn dat .NET/Visual Studio vind dat het Model project niet nodig is. Als ik de code zo een beetje door kijk, dan wordt nergens iets van het Model project gebruikt. Er is alleen een Reference gemaakt binnen het DAL project, maar dat is dan ook alles. Hierdoor zal de compiler waarschijnlijk denken dat het project overbodig is en dus niet in de bin map plaatsen.

Een kleine test bevestigde mijn vermoeden. Nadat ik een lege klasse had aangemaakt in het Model project en deze in de DAL gebruikte werd de Model dll ook in de bin map geplaatst.

In het Model project heb ik dus het volgende aangemaakt:

namespace OnsKoopje.Model

{

public class Empty

{

}

}

In m'n DAL project heb ik nu de volgende code geplaatst:

class ModelLink

{

private ModelLink()

{

var ep = new Model.Empty();

}

}

Aangezien het Model project nu wordt gebruikt in de DAL, wordt de dll nu ook mee gekopieerd naar de output directory van de service.

Het is een beetje een work-around voor het probleem, maar het werkt! Hopelijk wordt dit in de toekomst nog eens opgelost, tenzij ik echt met exotische dingen bezig ben, maar dat lijkt mij niet.

WSS3.0 SP2 event 6398 en registry
Al geruime tijd werkt het zoeken niet goed op m'n Sharepoint server waar ook dit weblog op draait. In de eventviewer zag ik het event 6398 continu terug komen.
Normaliter krijg je dit event te zien, samen met nog enkele anderen, en geven ze aan dat je de rechten op de dcom OSearch en de IWAM moet wijzigen.
Aangezien ik geen MOSS draai heb ik geen OSearch. Wel de IWAM, maar daar had ik de betreffende accounts al lokale activatie rechten op gegeven.
De fout die ik ook kreeg sloeg op het register:
Requested registry access is not allowed.
Heeft natuurlijk weinig met DCOM te maken. Jammergenoeg stond er niet echt een pad bij waar de accounts dan geen rechten op zou hebben.
 
Alle Sharepoint accounts in de Administrators groep plaatsen hielp niet.
Hier geeft iemand aan dat het mogelijk is dat de zoek database misschien corrupt is, dat was bij hem het geval.
 
Het kan natuurlijk zo zijn dat dit ook bij mij het geval is.
Wat ik nu heb gedaan is de zoekservice gestopt, daarna weer gestart, maar met een andere database naam.
 
Na de indexer weer te alloceren aan m'n web applicatie is die begonnen met indexeren. Ik heb het zoeken nu even getest met de term 'Sharepoint' en het lijkt te werken. Ik krijg in ieder geval resultaten terug die ik zou verwachten.
 
Eindelijk!
Entity Framework 4.0 in een N-Tier applicatie met WCF implementeren

Momenteel ben ik bezig om een nieuw project op te zetten waar ik gebruik wil gaan maken van het Entity Framework 4.0 en WCF. Aangezien .NET 4.0 net uit is, zou dit geen probleem meer moeten zijn.

Nu heb ik nog niet eerder goed met het EF gewerkt, dus is het allemaal nog redelijk nieuw voor mij. Gelukkig zijn er veel mensen die hier al het een en ander over hebben geschreven en ook duidelijke voorbeelden hebben gemaakt hoe het kan worden geimplementeerd.

Omdat ik toch graag een n-layer applicatie wil opzetten liep ik (onder andere) tegen het probleem aan dat het database model niet direct bekend is zijn op de client (de website). De verschillende objecten/entities zullen dus moeten worden geserialized om op de website te kunnen gebruiken. Dit is natuurlijk iets waar al menig ander tegenaan is gelopen, dus heb ik gezocht naar mogelijke oplossingen.

De eerste nuttige hit die ik heb gevonden was een post van Eliska Flasko uit het MSDN Magazine van April 2010 (http://msdn.microsoft.com/en-us/magazine/ee336128.aspx). Een heel duidelijk stuk waar mij de grote lijnen wel duidelijk werden. Tijdens het doorlopen van dit stuk zag ik dat ze hier gebruik maken van het ADO.NET EntityObject Generator template en niet de Self-Tracking variant.

Dit kan ik natuurlijk ook doen, maar dan zal ik het bijhouden van versies en dergelijke in een later stadium zelf moeten gaan bijhouden. Aangezien het EF-team hier waarschijnlijk beter over heeft nagedacht dan ik zou kunnen, wil ik dus voor de Self-Tracking kiezen.

Uiteraard zijn er ook mensen die dit al een keer hebben geimplementeerd en ben ik daar dus naar op zoek gegaan. Al vrij snel kwam ik uit op een post van het ADO.NET team van juni 2009 (http://blogs.msdn.com/adonet/pages/feature-ctp-walkthrough-self-tracking-entities-for-the-entity-framework.aspx). Ook weer een heel duidelijke post met allerlei screenshots ter verduidelijking.

Tijdens het lezen van de posts zag ik trouwens ook dat je een database kunt laten genereren door het EF aan de hand van het model dat je hebt gemaakt. Handig!

In de post van het ADO.NET team komt het er eigenlijk op neer dat je de T4 templates van het ADO.NET Self-Tracking Entity Generator template in het project maakt waar het model ook in staat. Dit is ook verplicht, aangezien de templates het edmx-bestand nodig hebben.

Zodra dit is gedaan maak je een link naar de T4 templates in de andere projecten. Zo heb ik het gegenereerde model in het DAL project ingeladen en de gegenereerde entities in het Model project, het resultaat is hieronder te zien.

Op deze manier zal alleen de DAL met de database kunnen praten en kun je de Entities overal gebruiken binnen je solution, mits je de reference natuurlijk aanmaakt.

Omdat ik nu self-tracking entities heb gemaakt, worden eventuele wijzigingen automatisch bijgehouden zodra ze vanuit m'n WCF service worden geserialized en op de client (website) gedeserialized.

Het is natuurlijk nog afwachten of alles ook in 1x goed werkt, maar het ziet er in ieder geval behoorlijk eenvoudig uit.

Eindelijk een MCPD titel

Gisteren was het dan eindelijk zo ver dat ik m'n 70-564 examen mocht doen. Dit examen is voor de titel MCPD ASP.NET Developer 3.5. Aangezien er niet echt studiemateriaal is voor dit examen, behalve dan de MSDN site, had ik besloten dit zo snel mogelijk na het bijbehorende MCTS examen in te plannen. Dit is een goede actie geweest.

Het examen heb ik gisteren met vlag en wimpel gehaald, waardoor ik nu een nieuw logo mocht maken op de MCP website.

 

Ik moet zeggen dat dit examen me behoorlijk mee viel. Bij het MCTS examen krijg je vaak code voorbeelden waar je echt goed in moet zoeken wat er fout is en behoorlijk wat in-depth kennis nodig hebt om te weten wat er allemaal wel en niet mogelijk is. Bij dit MCPD examen krijg je situaties voorgeschoteld waarna je een antwoord moet kiezen wat de beste oplossing voor de huidge situatie. Misschien is dat ook wel de bedoeling, dat je nu het breder plaatje moet kunnen overzien. Je hebt immers met het MCTS examen al bewezen dat je genoeg kennis hebt om de functionaliteit in te kunnen bouwen.

Wat ik nu ga doen? Denk eerst even enkele maanden niets, totdat de .NET 4.0 en Sharepoint 2010 examens klaar zijn.

Clean Code

De afgelopen tijd heb ik het boek Clean Code: A Handbook of Agile Craftmanship gelezen.

http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Een interessant boek met veel tips over hoe je beter code kunt maken en opleveren. Veel van de punten die hij behandeld zijn wel bekend bij de meeste ontwikkelaars, maar toch is het wel fijn om zo'n dergelijk boek te lezen eens in de zoveel jaar.

Na het lezen van een van de eerste hoofdstukken kun je al gelijk beginnen met het toepassen van de techniek die hij bespreekt. Zo schrijft Robert C. Martin onder andere dat functies (en klassen) klein dienen te zijn. Over het algemeen zou je een functie prima kunnen inkorten naar een regel of 10. Ik heb dit geprobeerd in de praktijk en het blijkt ook nog waar te zijn. Nu kun je je functies wel allemaal kleiner gaan maken, maar de functionaliteit moet er nog steeds in blijven zitten. Dit heeft natuurlijk als gevolg dat er ineens heel veel functies ontstaan. Deze kunnen weer worden ondergebracht in allerlei 'kleine' klassen.
Tevens kun je zo vaak al snel zien of je ook een overkoepelende abstracte klasse nodig hebt.

Om nu gelijk 'clean code' te maken is wel een beetje ondoenlijk heb ik ervaren. Je kunt beter uitgaan van een slechte situatie en die gaan verbeteren. Ik denk dat ik dat dan ook maar ga doen in de toekomst. Eerst de functionaliteit ontwikkelen in 'grote' blokken en daarna refactoren in kleinere stukken die beter en cleaner zijn.

Over het boek heb ik ook een kleine presentatie gehouden voor de afdeling. De slides zijn hier te vinden: http://www.slideshare.net/JandV/clean-code-summary

Ga nu verder met Working Effectively with Legacy Code. Hier verwacht ik ongeveer hetzelfde in aan te treffen als in Clean Code.

Windows LiveID op het blog

Het is me gelukt om nu ook een membership provider te implementeren waardoor er nu eindelijk weer gebruikers op het weblog in kunnen loggen. Hier heb ik wel wat hulp bij gehad van de Sharepoint Community Kit die op Codeplex is te vinden. Vanaf heden is het mogelijk om met een Windows Live ID in te loggen op dit weblog. Op zich mooi, maar wat heb ik er voor moeten doen, nou dat is eigenlijk heel eenvoudig.

Na wat zoeken en proberen kwam ik uiteindelijk uit op een CKS:WLA project bij Codeplex (http://cks.codeplex.com/releases/view/7746) Eigenlijk heb ik eerst het WLA project van deze site geimplementeerd: http://blog.solanite.com/keith/WLA/Documentation/Home.aspx. Omdat ik hier wat problemen mee had was ik op zoek naar enkele oplossingen. Uiteindelijk kwam ik dus bij het CKS project.

De implementatie is wel hetzelfde gebleven, echter zijn er enkele bugs in opgelost die nog wel in de 'oude' versie zaten.

De readme bij het project is ook behoorlijk duidelijk en eigenlijk ook een kopie van de oude site. Ik kopieer het hier even, zodat de informatie ook geborgd is, mochten ze besluiten het project off-line te halen.

Download the SharePoint Solution

   

The first step of the installation is to download the WSP solution file.  You can download the current version here.

   

Deploy the SharePoint Solution

   

In order to deploy the solution you need to make sure the WSP file is on the SharePoint server file system.  Then you should:

  1. Open a command prompt
  2. Change directory in to the directory you have downloaded the WLA.wsp file
  3. Type: "C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\bin\stsadm.exe" -o addsolution -filename WLA.wsp
  4. Type: "C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\bin\stsadm.exe" -o deploysolution -name WLA.wsp -immediate -allowgacdeployment
  5. Type: "C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\bin\stsadm.exe" -o execadmsvcjobs

This will install:

  • C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\LAYOUTS\liveinfo.aspx
  • C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\LAYOUTS\liveauth-handler.aspx
  • C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\CONFIG\stsadmcommands.addwindowsliveauth.xml
  • GAC: WindowsLiveAuth.dll

These files will be installed on all servers in the farm.

Register a Windows Live ID Application

Once the solution is installed you must make sure that you have registered your application with live.com.  Doing this will give you an Application ID and a secret key that you will use to identify your users to live.com and authenticate the response that will determine if the user is valid.

  1. Login to https://msm.live.com/app/default.aspx
  2. Click on the Register an Application link
  3. The Application Name is a name you will use to identify your application
  4. The Return URL must be set to http://your.servername.com/_layouts/liveauth-handler.aspx
  5. The Secret Key is the "password" that will be used to sign the authentication responses (this is the AppKey you will need later)
  6. Submit the registration
  7. Click on the Manage My Applications link

Using the Manage My Applications page you should remember the Application ID  (this is the AppId you will need later)along with the Secret Key you used when registering the application.

Configure the Authentication Provider

   

Once you have the provider installed and the application registered you need to configure the system to use this information.  A new STSADM command has been added to help with this process.  To complete the configuration you must:

  1. Go to the Central Administration home page
  2. Click on the Application Management tab
  3. Click on the Authentication providers link in the Application Security section
  4. Use the Web Application drop down to ensure that the correct web application is selected
  5. In the Zones list pick the zone you want to enable Live ID Authentication on (Default is probably going to be what you are looking for)
  6. Select the Authentication Type of Forms
  7. Enter a Membership provider name of LiveID
  8. Enter a Role manager name of LiveRoles
  9. Click the Save button

This has configured SharePoint to use the new Membership and Role providers, however there is one more configuration steps to configure the web applications to recognize the new providers.  You must:

  • Open a command prompt
  • Type: "C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\bin\stsadm.exe" -o addwindowsliveauth -appid <application id> -appkey <application secret key> -appmode <http/https - this is what url your users use> -profsite <URL of site that contains the profile list> -proflist <user profile list name> -locked <URL to send locked users to> -url <URL of the Web Application>
  • You must run this command for every Web Application you wish to have access to this user list (i.e. the Web Application that will authenticate Live ID users and Central Administration if you want Live ID users to be able to own site collections etc).  The one difference when running the command for different Web Applications will be the -url parameter.
  • Finally you need to add the defaultProvider for the Web Application that will authenticate Live ID users, you will replace the following in the web.config for the Web Application:
    • <membership> with <membership defaultProvider="LiveID">
    • <roleManager> with <roleManager defaultProvider="LiveRoles" enabled="true" cacheRolesInCookie="true" cookieName="liveroles">
    • You can find an example portion of the complete web.config here
  • Perform an IISRESET and you are done

Note: As a best practice you will want to have the profsite parameter set to a site that has restricted access as it will allow contributors to lock users.

Note: As a best practice the locked parameter should be a URL that has anonymous access and ideally has contact information about how to become unlocked.

Note: Live ID users will need to have the Edit Personal User Information  permission added to whatever role they have on the site to have access to change their personal information.

Het registreren van een Windows Live ID applicatie blijkt ook eenvoudig te zijn. Tegenwoordig lijkt het gecombineerd te zijn met de Azure Services, zoals hieronder is te zien:

Hier krijg je enkele belangrijke gegevens.

Door nu verder de readme te volgen kun je eigenlijk in 1x het project succesvol implementeren.

Ook kun je nu in de site collectie, waar de WLA is geinstalleerd, de groep Authenticated Live Users gebruiken, wat eigenlijk hetzelfde is als NT_AUTHORITY\Authenticated Users. Handig!

Hopelijk blijkt het een en ander ook stabiel te zijn, dat is nog afwachten natuurlijk.

Wat wel nuttig is om te vermelden is dat gebruikers na het registreren van het account op de site, ze nog wel zelf de gebruikersnaam moeten aanpassen.

Dit kan eenvoudig door op de naam te klikken en dan voor My Settings te kiezen

In het vervolgscherm is een Edit item link te zien waar op gedrukt kan worden om de profiel informatie te wijzigen:

Nogmaals MCTS

Afgelopen vrijdag heb ik het examen 70-562: TS: Microsoft .NET Framework 3.5, ASP.NET Application Development met succes weten te behalen. Dit was het tweede examen dat ik moest halen om m'n MCTS te halen voor ASP.NET development.

In totaal heb ik nu 3 MCTS titels bij elkaar gespaard.

.

Nu snel verder om het MCPD examen van ASP.NET development te halen. Zodra die is behaald staan de .NET 4.0 en Sharepoint 2010 examens ook alweer klaar, dus de komende tijd ben ik nog wel even zoet met studeren.

1 - 10 Next

 ‭(Hidden)‬ Admin Links

Jan V woont in het altijd gezellige Lemmer (Friesland), Nederland.
Hij is inmiddels al enkele jaren werkzaam als software ontwikkelaar.
Momenteel werkt hij bij Get There als een software- en Sharepoint ontwikkelaar.

In z'n vrije tijd is hij graag bezig om software en websites voor zichzelf en anderen te ontwikkelen.
Dit doet hij dan voor z'n eigen bedrijf Vinit.

Uiteraard mag hij ook graag z'n tijd vullen met andere bezigheden.
Lezen van boeken, spelen van een (bord)spelletje, lekker op stap, etc.

Waarom heeft Jan V een blog? Voornamelijk om het als uitlaatklep te gebruiken. Tijdens het ontwikkelen ontdekt hij wel eens iets dat nieuw voor hem is en dat deelt hij dan met de rest van de wereld.