Fout negeren

Door te klikken op het uitroeptekentje dat verschijnt als een cel met een groen hoekje wordt geselecteerd, verschijnt een keuzemenu. Kies Fout negeren om het groene hoekje van deze cel weg te halen.

Wanneer de formule wordt veranderd, zal Excel wel opnieuw een mogelijke fout markeren. Deze methode werkt ook voor een aantal cellen tegelijk. Selecteer eerst de cellen en klik op het uitroeptekentje en kies Fout negeren.

Helemaal uitzetten

Via Bestand – Opties – Formules – Foutcontrole kan de optie ‘Foutcontrole op de achtergrond inschakelen’ worden uitgeschakeld. Dit is een redelijk permanente oplossing. Er wordt geen enkele fout meer gemarkeerd.

In één keer uitzetten in VBA

Met onderstaande VBA-code kan op het specifieke niveau van het soort fout de foutcontrole worden uitgezet. Dit heeft hetzelfde effect als de eerste beschreven manier; na het aanpassen van een formule markeert Excel eventuele fouten. Alleen wanneer in een lege cel in de range een nieuwe ‘foute’ formule wordt ingevoerd zal deze de eerste keer worden genegeerd.

Option Explicit

Sub RemoveErrorChecks(rng As Range)

    Dim i As Integer
    Dim arrXlErrorChecks As Variant
    Dim cl As Range
    
       arrXlErrorChecks = Array(xlEvaluateToError, xlTextDate, xlNumberAsText, xlInconsistentFormula, _
          xlOmittedCells, xlUnlockedFormulaCells, xlEmptyCellReferences, xlListDataValidation, _
          xlInconsistentListFormula)
        
    For i = 0 To UBound(arrXlErrorChecks) - 1
        For Each cl In rng.Cells
            cl.Errors(arrXlErrorChecks(i)).Ignore = True
        Next cl
    Next i
   
End Sub

Sub test()
    RemoveErrorChecks Range("A1:E10")
End Sub

Naar wens kunnen de verschillende soorten fouten al dan niet worden genegeerd. Hieronder een beschrijving van de foutsoorten.

Kanttekening

Het is niet aan te raden om een heel werkboek zonder meer alle fouten uit te zetten, want in veel gevallen kunnen ze duiden op inconsistenties. Maar wanneer deze foutcontroles bijvoorbeeld effect hebben op performance dan kan het helpen.

In mijn onstilbare honger naar nieuwigheden in Office, loop ik regelmatig door de sjablonen heen die Word je biedt. Onder File, New… krijg je een hoeveelheid sjablonen voor je kiezen waar de honden geen brood van lusten; het gaat dan om duizenden… Ik vraag me dan altijd af waarom er zoveel sjablonen überhaupt gemaakt worden en door wie? En al die sjablonen hebben een eigen stijl, dus hoe kan dat ooit overeenstemmen met de huisstijl van de organisatie waar je werkt? Of zijn ze gemaakt voor ZZP-ers die (nog) geen vaste stijl hebben? Of zijn ze dan alleen gemaakt voor particulieren, die vooral de ‘Birthday gift certificate’ en de ‘Photo calendar’ gebruiken? Maar goed, mijn oog viel op de ‘Blog post’ en mijn interesse was gewekt. Voor sommige mensen is bloggen uitgegroeid tot een manier waarop ze hun ervaringen delen met de wereld. Een blog (afkorting voor weblog) geeft individuen de mogelijkheid van het publiceren zonder een beroep te hoeven te doen op de traditionele media-uitlaatkanalen of gedrukte publicaties. Iedereen die iets te zeggen heeft, heeft de mogelijkheid om het te zeggen op het web. Het enige wat ze nodig hebben is de nodige serverruimte en de juiste software om de blog-inhoud online te plaatsen. Het schrijven van een blogpost kan heel tijdrovend zijn. Vooral het ‘opmaak’ gedeelte van een blogpost. Toen ik met bloggen begon, gebruikte ik, bij gebrek aan kennis over andere vormen, de online editor van WordPress. Maar er zijn andere mogelijkheden, zoals het gebruik van Word. In mijn geval versie 2013. Sinds Microsoft Office 2007 biedt Word een eenvoudige manier om te bloggen. Word kan eenvoudig verbinding maken met WordPress (of een andere provider, zoals Blogger, SharePoint blog …) en biedt verder alles wat er nodig is om een blogbericht op te maken. De eerste keer na het openen van het “Blog post”-sjabloon, wordt gevraagd informatie over URL van het blog, evenals gebruikersnaam en wachtwoord. Uiteraard lukte mij dat niet in één keer, maar uiteindelijk lukte het. Onze URL voor blogs is flores.blogs.nl, dus ik probeerde eerst in ‘Blog Post URL’ de waarde http://flores.blogs.nl/xmlrpc.php. Niet goed dus. Zonder opgaaf van reden zegt Word:

Een heldere boodschap

De More Information brengt hopelijk soelaas: Help with blogging in Word. Onder de sectie ‘Help me fill out this section: WordPress, staat bijna wat ik nodig heb. Alleen de tekst ‘Your blog post URL is the URL of your WordPress xmlrpc.php file, which is usually located in the root folder of your site. For example, if your site is http://www.contoso.com, you type http://www.contoso.com/xmlrpc.php.‘ gaat er volgens mij vanuit dat je WordPress zelf host, wat volgens mij zelden gebeurt… Maar goed, dan maar eens proberen de URL van de beheer-pagina van WordPress in te voeren: http://floresblogs.wordpress.com/, met daarachter het magische xmlrpc.php bestandje. En ja hoor, het werkt (met de juiste User Name en wachtwoord). Top. Even uitproberen. Titel is Test, als tekst invullen ‘=Rand(10)’ – leuk trucje om snel even wat tekst in je document te krijgen. En dan ‘Publish’. Nee hoor, dat was iets te makkelijk. De compleet ‘heldere’ boodschap was:

Weer een heldere boodschap

Twee problemen: ten eerste mag ik niet direct posten, zonder dat de blog goedgekeurd is door onze strenge redacteuren .

Ok, dan Publish Draft. Dat gaat bijna goed, behalve de plaatjes. Toch wel belangrijk. Ervan uitgaande, dat WordPress dit allemaal aankan, kies ik ‘My blog provider’. Het zal wel met mijn beperkte rechten te maken hebben, maar geen succes. Dan bij ‘My own server’ proberen.

Na geruime tijd het internet te hebben afgestruind, op zoek naar de juiste instelling bij ‘Picture Options’ kom ik er niet uit. Ik heb nog even geprobeerd met een tijdelijk Flickr account verder gaan, maar ik kwam er niet uit. Bij Picture Options kan je kiezen uit ‘My blog provider’. Wat blijkt nu: ik ben slechts ‘schrijver’ (‘contributor’), wat een nogal zielige rol is: je mag dan geen plaatjes (media) invoegen. Na het wijzigen van mijn rol in Auteur (‘Author’) gaat het! Ik kan mijn blog in één keer publiceren. Geweldig.

Deze applicaties worden vaak EUC-applicaties of EUC’s genoemd: End User Computing-applicaties. En ze zijn overal. Dat is niet erg, wanneer maar wordt beseft wat de risico’s zijn en hoe deze risico’s kunnen worden beteugeld. Bij Flores Automatisering hebben we de afgelopen jaren veel ervaring opgedaan in het benoemen van de (technische) risico’s van EUC’s bij een aantal grote energiebedrijven. We hebben ze geholpen om de risico’s van EUC’s helder(der) te maken. Dat is een goed begin bij het verminderen van de risico’s.

Ontstaan van het risico

Veel afdelingen van organisaties baseren zakelijke en financiële beslissingen op spreadsheets (of andere EUC’s). Het gebruik van EUC-toepassingen heeft zich ontwikkeld van eenvoudige spreadsheets (zoals het bijhouden van facturen) tot geavanceerde en ingewikkelde analyse-instrumenten die het management gebruikt om belangrijke zakelijke beslissingen te nemen. Dit varieert van het genereren van zakelijke instructies, transactieberekeningen tot business cases voor grote investeringen.

Er zijn duidelijke voordelen en nadelen aan het gebruik van EUC-toepassingen. EUC-tools zijn vaak gemakkelijk te leren en te gebruiken, flexibel en goedkoop. Andere voordelen zijn de gebruiksvriendelijke interface van Office, eenvoudige numerieke manipulaties en scenario-analyses.

EUC-toepassingen worden echter dikwijls ontwikkeld en onderhouden door mensen met onvoldoende IT-ervaring op dit gebied. De kwaliteit van het ontwikkelwerk is af en toe goed, maar onderhoud (back-up, herstel, controle op wijzigingen, documentatie) zijn vrijwel nooit in orde. Dit proces is ook in strijd met de basisfilosofie “scheiding van taken”: de bouwer van de tool is vaker wel dan niet tevens de gebruiker van de applicatie.

Dit resulteert in een groot risico voor de organisatie en de gebruikers van deze tools, die vaak afhankelijk zijn van de goede werking van deze EUC’s bij het maken van de juiste, op feiten gebaseerde operationele of bedrijfsbeslissingen.

Risico’s van EUC’s

EUC’s, met name MS Excel-spreadsheets, hebben sterke beperkingen en zwakke punten in het omgaan met grote hoeveelheden data en gecontroleerde gebruikerstoegang. De risico’s van EUC’s zijn des te groter als de EUC-toepassing wordt gebruikt in een instabiele of slecht gecontroleerde omgeving. Een deel van de risico’s voor de EUC zijn:

• Slechte input, die leidt tot een lage kwaliteit van de gegevens;
• Gebrek aan controle over gebruikerstoegang;
• Gemaakte wijzigingen zijn onvoldoende getest en gedocumenteerd;
• Gebrek aan documentatie met betrekking tot het gebruik;
• Gebrek aan een audit trail van de genomen besluiten;
• Onvoldoende versiebeheer en
• Inefficiëntie, dubbel werk.

Al deze fouten kunnen leiden tot onvolledig begrip van de gebruiker, onjuiste gegevensstromen, gebrek aan logica, gebruik van verschillende versies en andere gebreken die een negatieve invloed hebben op het nemen van de juiste bedrijfsbeslissingen.

Risicoanalyse van EUC in de praktijk

Een goed ontworpen werkboek heeft een lager risico, zeker wanneer universele ontwerpprincipes worden gehanteerd. Op basis van ervaringen uit de praktijk is een aantal ontwerpprincipes uitgewerkt in een checklist. Flores heeft voor enkele klanten de checklist gebruikt om te bepalen wat het risico is van een werkboek. Het risico van een werkboek kan worden ingeschat door aan elk van onderstaande items een score toe te kennen van Laag, Midden of Hoog. Het beste effect wordt bereikt als meer dan één persoon deze scores toekent, en een gemiddelde wordt genomen van de rapporteurs.

Structuur werkboek

Maak onderscheid tussen werkbladen met invoer, berekeningen en uitvoer.
Onderscheid maken tussen werkbladen met invoer, berekeningen en uitvoer, maakt de werking van een werkboek inzichtelijker. Het werkboek wordt makkelijker in het gebruik: het is goed zichtbaar waar alle invoer moet worden gedaan. Door invoer te groeperen, zal minder snel invoer op verschillende plaatsen in het werkboek worden gedaan. Het is praktisch om de werkbladen (en cellen) een kleur te geven afhankelijk van hun functie (invoer, berekeningen en uitvoer).

Overzichtelijk gebruik van celstijlen: oranje cellen voor invoer, grijze cellen voor formules

Volgorde berekeningen
Formules die afhankelijk zijn van (waardes of formules van) andere cellen kunnen over het algemeen binnen een werkblad het beste geordend worden van links naar rechts, van boven naar beneden en binnen het werkboek, van voor naar achter. Voor een mens is dit logischer te begrijpen en daarom makkelijker. Voor Excel zelf maakt het niet uit; formules die naar andere cellen verwijzen kunnen voor of achter de genoemde cellen worden geplaatst. Dit komt omdat Excel geen cellen berekent in een vaste volgorde, of rij of kolom.

Geef werkbladen duidelijke namen, gebruik (sub)kopteksten boven gegevens
In een organisatie met Engels als voertaal, zelfs in het geval dat alleen zo is onder delen van het personeel, is het aan te raden om Engelse benamingen te gebruiken. Dit, in het kader van het eventueel uit handen geven van het beheer van de tool aan een derde partij. Daarnaast moeten werkbladen natuurlijk duidelijke beschrijvende namen hebben en niet Sheet1, Sheet2…

Eenvoudige formules
Een geneste functie is een functie binnen een functie, zoals =ALS(D2<10000;”Slecht”;ALS(D2>=20000;”Zeer goed”;”Goed”)). Het gebruik van complexe geneste formules is af te raden, omdat waarschijnlijk alleen de opsteller van de formule deze goed begrijpt. Het verdient de voorkeur om een formule op te splitsen in verschillende kleinere berekeningsstappen. Eenvoudige formules zijn beter te controleren, te veranderen en ze zijn minder vaak incorrect. Om die reden, bij voorkeur niet gebruiken:

• Ingewikkelde IF-formules;
• Ongebruikelijke Excel-functies;
• Matrix (of Array-)formules (Matrix- of array-formules worden niet vaak gebruikt en er is dan ook weinig documentatie over beschikbaar. Bovendien kan het gebruik van grote matrixformules veel rekenkracht vergen op werkstations met minder verwerkingscapaciteit);
• User Defined Functions (UDF – gebruikersgedefinieerde functies): de definitie van een UDF kan worden gemaakt in programmeercode (VBA) en moet ergens opgeslagen worden en beschikbaar zijn voor de gebruikers. Om code in een werkboek op te slaan, moet het werkboek worden opgeslagen als Excel-werkboek met macro’s (.xlsm), met daarbij de mogelijke veiligheidsrisico’s. Een mogelijke oplossing is de UDF’s op te slaan als invoegtoepassing (add-in). Dit heeft wel als praktisch probleem dat een invoegtoepassing voor alle gebruikers beschikbaar moet worden gesteld. Hierover volgt nog een nieuwe blogpost.
• Verborgen rijen of kolommen, tenzij deze wijs worden gebruikt om complexe berekeningen (zie eerder) op te delen

Named ranges
Goed gebruik van named ranges (Excel-namen) maakt formules beter leesbaar. Een Named Range is een duidelijke beschrijving, waarmee het gemakkelijker wordt te begrijpen wat het doel is van een cel of een verzameling cellen. Voorbeelden van goed gebruik van namen zijn: TariefBTW of Startdatum. Deze namen kunnen in berekeningen in het gehele werkboek worden gebruikt. Zie ook dit artikel van Microsoft.

Eenheden consistent vermelden
Om verwarring over eenheden te voorkomen is het noodzakelijk dat bij elke kolom de gehanteerde eenheid wordt vermeld in de kolomkop: meter, liter, TW/GW/MW/kW/kWh, EUR, Y(ear), (Q)uarter, enz.

Datumkolom
Een datumkolom wordt vaak gevuld door in elke cel een datumwaarde te zetten. Het is beter om een datum te laten berekenen ten opzichte van een datum (=MONTH(StartDatum)). Dit om verkeerd kopiëren te voorkomen.

Consistente opmaak
Een van de meest onderschatte onderdelen bij het verminderen van risico’s die EUC’s met zich meebrengen is het consistent gebruiken van opmaak. Gek genoeg zijn veel mensen wel overtuigd van het nut van het consistent opstellen van een offerte in Word of een presentatie in PowerPoint, in Excel lijkt het soms het wilde westen als het gaat om opmaak. Iedereen hanteert zijn eigen kleuren, lettertypes, randen, enz., waarmee het werkboek zeer moeilijk is te vergelijken met andere werkboeken met een volledig andere opmaak. Het gebruik van celstijlen is zeer aan te raden. Lees hierover meer in dit Microsoft-artikel.

Gebruik van Excel-tabellen en gestructureerde verwijzingen
Gegevenslijsten moeten altijd in een Excel-tabel worden gezet, omdat Excel dan zorgt voor consistentie binnen de kolommen. Een ingevoerde formule in een Excel-tabel wordt automatisch gekopieerd naar de hele kolom. Door gestructureerde verwijzingen te gebruiken worden celverwijzingen automatisch aangepast bij de meeste wijzigingen. Tip: druk op CTRL-L om gegevens om te zetten in een tabel. Zie ook dit artikel van Microsoft.

Invoercontrole
De invoer van gebruikers kan worden gevalideerd met gegevensvalidatie (validatie op celniveau). Ook kunnen controleformules worden gebruikt; dit werkt vaak inzichtelijker omdat de formule ook in het werkboek staat. Controleformules kunnen ook gebruikt worden om de resultaten van (tussenliggende) berekeningen te controleren.

Bijzondere werkbladen
Het is aan te raden om in elk werkboek een aantal vaste werkbladen aan te maken met specifieke functies. Deze werkbladen hebben een rol bij het versiebeheer, controle van invoer en overzichtelijkheid van het werkboek.

Op het configuratiewerkblad kunnen standaardwaarden, modelparameters en opzoektabellen worden geplaatst.

Het controlewerkblad bevat controleformules om te kijken of de resultaten plausibel zijn. Het is aan te raden om gedurende de ontwikkeling van een werkboek telkens controles toe te voegen, in plaats van op het laatst te proberen te bedenken wat er allemaal verkeerd kan gaan.

Een revisiewerkblad met een beschrijving van de wijzigingen, datum en auteur van de laatste versie is nuttig om samenwerken aan dezelfde EUC-toepassing mogelijk te maken. Dit is ook een goede plaats om beslissingen over wijzigingen op te slaan om later op terug te kunnen kijken.

Bevat een beschrijving over het gebruik, de betekenis van de werkbladen en het nut van werkboek.

Een navigatiewerkblad kan gebruikt worden om het model inzichtelijk te maken, bijvoorbeeld door de werkbladen in een stroomschema op te nemen.

Hulp bij spreadsheetmanagement

Dit blogartikel geeft een globaal beeld van de risico’s van het gebruik van spreadsheets. We hebben een aantal aandachtspunten genoemd, waarop gelet kan worden bij het doen van een technische scan. Door een technische scan uit te (laten) voeren worden de risico’s van een spreadsheet duidelijk gemaakt en kunnen stappen worden genomen de risico’s te beteugelen, bijvoorbeeld door de EUC te verbeteren, te vervangen door een beter gecontroleerde applicatie of door de EUC buiten werking te stellen.

Wilt u meer weten over EUC’s, onze risicoscan van Excel en het beheersen van risico’s die EUC’s met zich meedragen, neem dan contact op met ons. Wij helpen u graag!

Martin Drenth
Toon Michel

Ron de Bruin
The most comprehensive source for tutorials about customizing the user interface (ribbon and backstage view) of Office 2007, 2010, 2013.

Greg Maxey
A seasoned Word expert who wrote many articles about for instance using building blocks and merge fields in Word.

Word MVP site
MVP’s are Microsoft Valued Professionals. This website is the central storage place of many articles about Word by MVP’s. The site looks a bit outdated, but many articles are still valid.

Cindy Meister
Another Word and mail merge expert.

Graham Mayor
Graham Mayor, an expert in Word fields and macros.

Blogs Office
Last news about new versions of Office. A lot of ooh’s and aah’s about Office 2013.

Office development reference manual
The official source on the Microsoft Software Developers Network (MSDN).

PowerPoint Ninja
Last but not least, tips and tricks and best practices about creating PowerPoint templates.

Een Word-document dat gemaakt wordt op basis van een documentsjabloon wordt vanzelf gekoppeld aan dat sjabloon. Daarmee worden in het document een aantal elementen uit het sjabloon beschikbaar (voor zover dit sjabloon deze elementen bevat):

• Bouwstenen/snelonderdelen (Building Blocks/Quick Parts)
• Macro’s
• Aanpassingen in het lint (Ribbon customizations)
• Aanpassingen in de snelle toegang-knoppen (Quick Access Toolbar)
• Sneltoetsen (Shortcuts)
• Aangepaste opdrachten (Command settings)

Er zijn verschillende mogelijkheden om de elementen uit het sjabloon weer beschikbaar te maken.
1. Zorg dat het sjabloon op dezelfde plaats staat als het stond toen het document werd gemaakt. Een document is gelinkt aan het sjabloon met een padverwijzing. Via de knop Documentsjabloon op de tab Ontwikkelaars* is te zien waar Word verwacht dat het sjabloon staat.
2. Plaats het sjabloon in de Opstarten-, Gebruikerssjablonen- of Werkgroepsjablonen-map (vraag systeembeheer dit te doen voor alle gebruikers bijvoorbeeld). De sjabloon-elementen worden dan overigens wel beschikbaar in álle documenten.
3. Link het document aan het sjabloon op de nieuwe plaats (bijvoorbeeld als 1. niet lukt) via de knop Document template op de tab Ontwikkelaars (Developer)*.
4. Plaats het sjabloon in dezelfde map als het document. Word zal de link automatisch aanpassen.
5. Via het Word VBA-commando kan ook het documentsjabloon worden gelinkt. Gebruik daarvoor:
ActiveDocument.AttachedTemplate = "[pad]\[sjabloonnaam].dotx"

* Als de Ontwikkelaars-tab niet zichtbaar is:
Bestand – Opties – Lint aanpassen
Klik onder Het lint aanpassen op Hoofdtabbladen
Schakel in de lijst het selectievakje Ontwikkelaar in en klik op OK.

Zie ook:
Een Word-document opslaan als sjabloon

Libraries bouwen in .NET is goed mogelijk, maar zorgen dat deze library te gebruiken is in VBA levert vaak problemen op. In deze walkthrough is het ontwikkelen van een library voor Office met C# beschreven.

Wat moet er allemaal gebeuren?

Voor de programmeurs met de juiste kennis is dit wellicht al voldoende:

• Zorg dat er een constructor is (ook als je geen code daarvoor hebt).
• Zorg dat de class een interface heeft.
• Zorg dat de class gesigned is
• Zorg dat de compiler directives voor COM aanwezig zijn in de class en in de interface.
• Registreer met de juiste tools de class.

Gebruikte techniek

Visual Studio 2010 (C#), Microsoft Word 2003 of hoger (VBA).

Het project

In dit voorbeeld wordt een library gemaakt die de uitslagen van de Nederlandse Olympische 2012 medailles kan geven. Deze library krijgt de naam OS2012NL.

1. Start Visual Studio 2010 en start een nieuw C# Class Library project en noem het OS2012NL.
2. Hernoem de class1.cs bestand naar naar Medals.cs. Zorg dat de class ook deze naam heeft.
3. Implementeer de class als volgt zodat hij in de basis klaar is.

using System;
using System.Collections.Generic;

namespace OS2012NL
{
    public class MedalOverview
    {
        public enum MedalType
        {
            Gold,
            Silver,
            Bronze
        }

        public int getMedalCount(MedalType medal){
            switch (medal)
            {
                case MedalType.Gold:
                    return 6;
                case MedalType.Silver:
                    return 6;
                case MedalType.Bronze:
                    return 8;
                default:
                    return 20;
            }
        }

        public string[] getSports(MedalType medal)
        {
            switch (medal)
            {
                case MedalType.Gold:
                    return new string[]{"Swimming","Sailing","Hockey", "Cycling", "Gymnastics"};
                case MedalType.Silver:
                    return new string[]{"Swimming","Sailing","Hockey", "Equestrian"};
                case MedalType.Bronze:
                    return new string[]{"Swimming","Sailing", "Equestrian", "Judo", "Cycling BMX", "Cycling track", "Rowing"};
                default:
                    return new string[] { "Swimming", "Sailing", "Hockey", "Cycling", "Gymnastics", "Equestrian", "Judo", "Cycling BMX", "Cycling track", "Rowing" };

            }
        }
    }
}

Je kan hem nu probleemloos vanuit een .NET-applicatie aanroepen. Test dit door een console-applicatie toe te voegen aan het project en de volgende code te gebruiken.

using System;
using System.Collections.Generic;
using OS2012NL;

namespace TestOS2012NL
{
    class Program
    {

        static MedalOverview mo = new MedalOverview();

         static void Main(string[] args)
        {
            Console.WriteLine(mo.getMedalCount(MedalOverview.MedalType.Gold));

            printMedals(MedalOverview.MedalType.Gold);
            printMedals(MedalOverview.MedalType.Silver);
            printMedals(MedalOverview.MedalType.Bronze);

            Console.WriteLine("press a key");
            Console.ReadKey();
        }

        static void printMedals( MedalOverview.MedalType medal)
        {
            Console.WriteLine();
            Console.WriteLine(string.Format("the Netherlands won {0} {1} medals in the following sports:", mo.getMedalCount(medal),medal.ToString() ));
            foreach (String item in mo.getSports(medal))
            {
                Console.WriteLine(item);
            }

        }
    }
}

Maar goed, we willen hem voor Office beschikbaar gaan maken. Je kan beginnen door hem te laten registreren voor COM Interop, door bij de properties van de klasse onder Application, Assembly Information een vinkje aan te zetten bij “Make assembly COM-visible” Dit lijkt te werken, maar dat is niet genoeg als je met Office werkt.

Om de class geschikt te maken voor Office, moet je de volgende “zaken” regelen.

• Zorg dat er een constructor is.
• Zorg dat er een interface is
• Zorg dat de interface en de klasse strong named zijn
• Zorg dat de compiler directives aanwezig zijn in je klasse en in de interface.
• Registreer met de juiste tools je klasse.

De constructor toevoegen.

In VB.NET voeg een sub New toe en in C# plaats je:

public MedalOverview()
{
}

Ook al hebben we geen code voor de constructor.

De interface

Natuurlijk denk je normaal eerst goed na en schrijf je eerst je interface en dan pas je code. We doen het nu even pragmatisch en construeren via Refactor, Extract Interface een interface. Noem hem iMedalOverview en maak zowel beide functies public en de interface public.

using System;
namespace OS2012NL
{
    public interface IMedalOverview
    {
        int getMedalCount(MedalOverview.MedalType medal);
        string[] getSports(MedalOverview.MedalType medal);
    }
}

Visual Studio heeft naast het schrijven van de interface ook je class aangepast. Er staat nu:

public class MedalOverview : OS2012NL.IMedalOverview

De klasse signen

Dit hoeft geen ‘echt’ certificaat zijn. Ga in Visual Studio naar de eigenschappen van het project van OS2012NL en zet bij Signing, Sign the assembly aan. Gebruik een bestaand certificaat aan of genereer er hier een.

Compiler directives toevoegen

Met een paar compiler directives in de code hoeven we niet op zoek te gaan naar allemaal vinkjes in Visual Studio en zetten we in één klap een GUID, de COM-instellingen en een program ID.

Neem in de klasse en in de interface eerst een verwijzing op naar de InteropServices

using System.Runtime.InteropServices;

Bepaal daarna een nieuwe GUID voor je klasse, dit kan je in Visual Studio onder Tools doen (Create GUID, type 5 als je in C# werkt). Neem dit GUID op in de volgende code die je voor de class-declaratie opneemt.

[Guid("E74DF58D-7155-4B20-9484-203E6AF28F20"),
ClassInterface(ClassInterfaceType.None),
ProgId("OS2012NL"), ComVisible(true)]
public class MedalOverview : OS2012NL.IMedalOverview

In de Interface neem je enkel een nieuw GUID en COM-visible op.

[Guid("A0478EFB-5D5D-40E1-9B90-F1035218A6B6")]
[ComVisible(true)]
public interface IMedalOverview

Goed, de klasse is klaar. Maar Office kan niet direct met een COM DLL praten en het heeft hier een zogenaamd TLB-bestand voor nodig. Dit creëer je eenvoudig met Regasm uit het .NET framework. Deze staat in C:\Windows\Microsoft.NET\Framework\v4.0.30319 (of in de map van de andere versies van het framework)

Ga naar een command prompt, ga naar de release folder van het project en tik:
C:\Windows\Microsoft.NET\Framework\v4.0.30319\regasm.exe OS2012NL.dll /tlb: OS2012NL.tlb /codebase

Pas op! Als je dit doet op een 64-bits machine dan moet je regasm uit het 64 bits path van het framework gebruiken: C:\Windows\Microsoft.NET\Framework64\v4.0.30319. Pak je de verkeerde dan wordt je DLL wel geregistreerd, maar zal hij foutmeldingen geven.

Als het goed is, maakt Regasm een TLB-bestand aan en is de dll geregistreerd.

De klasse in VBA gebruiken

Ga in een Office-applicatie naar VBA.

Als het goed is vind je onder Tools – References de dll terug (feitelijk is dat een link naar het TLB-bestand)

Referenties dialoog in VBA

Staat hij er niet bij, dan kun je met Browse het TLB-bestand aanwijzen.

Vink hem aan en probeer of tik de volgende code.

Sub Macro1()
    Dim objOS As New OS2012NL.MedalOverview
    Dim sports() As String

    sports() = objOS.getSports(MedalType_Silver)

    For Each s In sports()
       Debug.Print s
    Next s
End Sub

Deployment

Je kunt nu de dll naar een machine kopiëren en regasm gebruiken. Heb je het TLB-bestand al gemaakt dan kan je ook Regtlbv12.exe gebruiken. Deze kan meteen de TLB registeren, maar ik gebruik eigenlijk altijd Regasm.

Problemen en oplossingen

De DLL registreert, maar doet het niet.

Heb je wel de juiste versie van Regasm gebruikt? 64 bits machines moeten de regasm uit de Framework64-map van het .NET-framework gebruiken.

Intellisense laat mijn methoden niet zien

Heb je de properties en functies en de klasse zelf public gemaakt? Heb je de interface gemaakt?

Can’t create Active X component

• Heb je de juiste regasm gebruikt? (zie probleem 1)
• Gebruikt je DLL niet zelf weer een dll die niet goed geregistreerd is of afwezig? Vaak kan je de refererende dll in Visual Studio gewoon meekopiëren naar de map waar je je dll plaatst. Over .NET dll’s hoef je je niet druk te maken.
• Heb je de constructor wel gemaakt?

As many companies I worked for are using DevExpress controls I decided to write a couple of posts about some real life situations and ways they can be solved by using DevExpress ASP.NET Suite. In this and the following post I will show a couple of techniques on how to achieve a certain behavior that goes slightly further than the demo examples that you can find on DevExpress site.
I will be using ASP.NET suite of controls, more specifically Web Forms.

At the end of the article this is the expected result:

You can also check the LIVE DEMO.

Table of contents

1. What are DevExpress controls?
2. Requirements
3. The project
4. Creating a data source
5. The web page
6. Defining a detail grid
7. Adding a context menu to the detail grid
8. Programmatically disabling menu items
9. Aesthetic changes
10. Downloads and the source code
11. Notes and other resources

What are DevExpress controls?

A set of controls that enrich your toolbox by adding several controls that are not present in the standard ASP.NET controls and some of the controls that are offered as a good substitute to already existing controls. All of the DevExpress controls are rich by the properties, methods and events both on client and server side, giving you the possibility to achieve results that otherwise will require a lot more extra coding.

Requirements

All of my examples are written for .NET 4.0 with Visual Studio 2010 using the version v2012 vol 1.5 of DevExpress controls. You can find a trial version of the requested controls here DevExpress Demo. Any version of Visual Studio is just fine, from Express to Ultimate. Also you can easily migrate this project to .NET 3.5 if needed. In case that the version of DevExpress controls I used is not available anymore, it should be easy to upgrade the project by DXperience Project Converter. For more information on the project converter check the DevExpress web site.

The project

I will start with the default Visual Studio ASP.NET Web Application.
Because this example is about the UI and the controls itself, I will put no emphasis on the data source and just create a super simple data model. We will have two data entities, User and Project. As a cardinality, we have a many-to-many relationship, so one user can be related to many projects and a project can have several users. Also I will create a class called DataService that will create a couple of values that will represent our data.

Let’s start!

Creating a data source

First we will create a Project class. In the default constructor we will set the project status property to new. Except for this, we will have three properties, an ID, project name, and a project status.

public class Project
{
    public Project()
    {
        Status = ProjectStatus.New;
    }

    public int ID { get; set; }
    public string Name { get; set; }
    public ProjectStatus Status { get; set; }
}

As you can see, project status is an enumerator, so let’s define it together with other possible project statuses.

public enum ProjectStatus
{
    New,
    InProgress,
    Failed,
    Done
}

Now we will define the user class. It has several properties and one public method. The method returns the number of associated projects of the current customer instance.

public class User
{
    public User()
    {
        Projects = new List<Project>();
    }

    private string m_fullName;

    public int ID { get; set; }
    public string UserName { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public List<Project> Projects { get; set; }

    public string FullName
    {
        get { return string.Format("{0}, {1}", this.LastName, this.FirstName); }
    }

    public bool HasProjects()
    {
        return Projects.Count > 0;
    }
}

This is a very simple model and probably in a real life situation your model will of course be richer with properties and methods.
Next to come is a class that will create several instances of the model classes and return them via a method. In this way we can have easily all the data we need for our example. The code I used is the following, you can add other data if you are looking for a particular behavior.

[DataObject(true)]
public class DataService
{
    [DataObjectMethodAttribute(DataObjectMethodType.Select, true)]
    public static List<User> GetUsers()
    {
        List<User> users = new List<User>();

        users.Add(new User() { ID = 1, UserName = "JohnDoe", FirstName = "John", LastName = "Doe", Projects = GetSomeProjects() });
        users.Add(new User() { ID = 2, UserName = "JimDoe", FirstName = "Jim", LastName = "Doe", });
        users.Add(new User() { ID = 3, UserName = "RobertDoe", FirstName = "Robert", LastName = "Doe", });
        users.Add(new User() { ID = 4, UserName = "AlisonDoe", FirstName = "Alison", LastName = "Doe", Projects = GetSomeProjects2() });

        return users;
    }

    [DataObjectMethodAttribute(DataObjectMethodType.Select, false)]
    private static List<Project> GetSomeProjects()
    {
        List<Project> projects = new List<Project>();

        projects.Add(new Project() { ID = 1, Name = "Test1" });
        projects.Add(new Project() { ID = 2, Name = "Test2", Status = ProjectStatus.Failed });
        projects.Add(new Project() { ID = 3, Name = "Test3" });

        return projects;
    }

    [DataObjectMethodAttribute(DataObjectMethodType.Select, false)]
    private static List<Project> GetSomeProjects2()
    {
        List<Project> projects = new List<Project>();

        projects.Add(new Project() { ID = 4, Name = "Test4" });
        projects.Add(new Project() { ID = 5, Name = "Test5", Status = ProjectStatus.Failed });
        projects.Add(new Project() { ID = 6, Name = "Test6", Status = ProjectStatus.InProgress });

        return projects;
    }
}

Now our data source is ready. The next thing to care of is the web page itself.

The web page

Add the grid by drag dropping the ASPxGridView control in the page. Modify the properties in order to match the following:

<dx:ASPxGridView ID="gvMaster" runat="server" AutoGenerateColumns="False" KeyFieldName="ID"
    Width="100%" >
    <Columns>
        <dx:GridViewDataTextColumn FieldName="ID" VisibleIndex="0">
        </dx:GridViewDataTextColumn>
        <dx:GridViewDataTextColumn FieldName="UserName" VisibleIndex="1">
        </dx:GridViewDataTextColumn>
        <dx:GridViewDataTextColumn FieldName="FirstName" VisibleIndex="2">
        </dx:GridViewDataTextColumn>
        <dx:GridViewDataTextColumn FieldName="LastName" VisibleIndex="3">
        </dx:GridViewDataTextColumn>
        <dx:GridViewDataTextColumn FieldName="FullName" VisibleIndex="4">
        </dx:GridViewDataTextColumn>
    </Columns>
</dx:ASPxGridView>

What I did is changing the grids ID to gvMaster, indicating the Key field name by setting the KeyFieldName to “ID” and specifying the columns that will be shown together with mapping a column field name to the desired model property. Now we need to bind the grid and we will do it from the code.
In order to be able to show the changes, we will save our data in a session and in order to ease this operation we will create a property that will perform all of this check and operations for us. Get in the page’s code file and declare the following.

public List<User> Users
{
    get
    {
        if (Session["Data"] == null)
            Session["Data"] = DataService.GetUsers();

        return (List<User>)Session["Data"];
    }
    set { Session["Data"] = value; }
}

When the property is requested for the first time, the session item is null, then we will recall the method that we created previously and save the data in the session. This is not a technique that you will use in a real life application, because probably you will recall the data from the database at a certain point and eventually cache it. As explained, this is not the goal of this article, so I will just mention it.
Now it’s time to bind the grid to this property.

protected void Page_Load(object sender, EventArgs e)
{
    if (!IsPostBack)
    {
        gvMaster.DataSource = Users;
        gvMaster.DataBind();
    }
}

If you run the code now you should see the following (or a similar screen, don’t worry if the theme that is applied doesn’t look the same, we will come to that later).

Defining a detail grid

In order to add a detail grid to a master grid, we first need to define a template for the detail row. Inside the aspx file get inside the definition of ASPxGridView and open the <Templates> section then inside the newly created section a new one called <DetailRow>. Close properly both sections. In the Detail Row template add a new ASPxGridView and define as for master grid the columns and some properties. Also do not forget to set the ShowDetailRow property to true. At the end your code should look like this.

<SettingsDetail ShowDetailRow="True" />
<Templates>
    <DetailRow>
        <dx:ASPxGridView ID="gvDetail" runat="server" Width="100%" KeyFieldName="ID">
            <Columns>
                <dx:GridViewDataTextColumn FieldName="ID" VisibleIndex="0">
                </dx:GridViewDataTextColumn>
                <dx:GridViewDataTextColumn FieldName="Name" VisibleIndex="1">
                </dx:GridViewDataTextColumn>
                <dx:GridViewDataTextColumn FieldName="Status" VisibleIndex="2">
                </dx:GridViewDataTextColumn>
            </Columns>
        </dx:ASPxGridView>
    </DetailRow>
</Templates>

Now we need to handle the binding of the detail grid. Before that, we will check for each row in the master grid if there is the data for the detail grid and if not, hide the plus sign. To achieve that, we need to declare the OnDetailRowGetButtonVisibility event on the master grid. The code of your master grid should look like this:

<dx:ASPxGridView ID="gvMaster" runat="server" AutoGenerateColumns="False" KeyFieldName="ID"
    Width="100%" OnDetailRowGetButtonVisibility="gvMaster_DetailRowGetButtonVisibility">

In the server side event code we need to check if there are detail data for each master element.

protected void gvMaster_DetailRowGetButtonVisibility(object sender, ASPxGridViewDetailRowButtonEventArgs e)
{
    User currentUser = Users.Find(u => u.ID == (int)gvMaster.GetRowValues(e.VisibleIndex, "ID"));

    if (!currentUser.HasProjects())
        e.ButtonState = GridViewDetailRowButtonState.Hidden;
}

For the less experienced, I will quickly explain this code. In order to get the row value we will use the argument that is passed to the event which contains the currently processing row visible index and with that information retrieve the value of the ID field of that row. The following code gvMaster.GetRowValues(e.VisibleIndex, "ID")) will give us the the value of ID filed for the current row. Then we will retrieve the User class instance for a given ID and check if it has a project. In case that this user is not associated to any project we will hide the plus sign (button) for that row with by setting the argument property ButtonState to hidden.
Now let’s bind detail grid.
Each time the user clicks on the plus sign, a callback will be automatically generated by the grid on the server side, and a binding event for the detail grid will be raised. OnBeforePerformDataSelect event in the detail grid is the right one for indicating the data source on which the current detail grid should be bind. Define the previously mentioned event:

<dx:ASPxGridView ID="gvDetail" runat="server" Width="100%"
    OnBeforePerformDataSelect="gvDetail_BeforePerformDataSelect" KeyFieldName="ID">

And bind the data in that event.

protected void gvDetail_BeforePerformDataSelect(object sender, EventArgs e)
{
    ASPxGridView grid = sender as ASPxGridView;
    int currentUserID = (int)grid.GetMasterRowKeyValue();

    grid.DataSource = Users.Find(u => u.ID == currentUserID).Projects;
}

In order to refer to a proper object we need to cast the sender of the event to a ASPxGridView. Then DevExpress grid comes in our help with GetMasterRowKeyValue() method, which as it’s name says, will return the key value of the master grid in which our current detail grid is defined. With that value, which is basically the User ID, we can retrieve the necessary data which we will be set as a DataSource of the current detail grid.
That’s it, your master detail grid should work now and this is how it should look like.

If your solution is not looking completely the same do not worry, important is that it compiles and shows the data correctly for now.

You can see that I’m constantly pointing for the detail grid the current fact. This is important, because we can have multiple detail grids in the page, so we always need to refer to a proper object. Always think about that when you are working with detail grid.

Adding a context menu to the detail grid

This is a bit more complicated task but as you will see a quite simple way to achieve this.
Start with adding a client side event ContextMenu on the detail grid:

<dx:ASPxGridView ID="gvDetail" runat="server" Width="100%" OnBeforePerformDataSelect="gvDetail_BeforePerformDataSelect"
   KeyFieldName="ID">
    <Columns>
        <dx:GridViewDataTextColumn FieldName="ID" VisibleIndex="0">
        </dx:GridViewDataTextColumn>
        <dx:GridViewDataTextColumn FieldName="Name" VisibleIndex="1">
        </dx:GridViewDataTextColumn>
        <dx:GridViewDataTextColumn FieldName="Status" VisibleIndex="2">
        </dx:GridViewDataTextColumn>
    </Columns>
    <ClientSideEvents ContextMenu="OnContextMenu" />
</dx:ASPxGridView>

And then defining a menu with a couple of items in it (just drag and drop PopupMenu control from the toolbox in the page):

<dx:ASPxPopupMenu ID="detailContextMenu" runat="server" ClientInstanceName="detailContextMenu">
    <Items>
        <dx:MenuItem Name="cmdResetTest" Text="Reset Test" ToolTip="Reset Test to New Status">
        </dx:MenuItem>
    </Items>
</dx:ASPxPopupMenu>

With DevExpress controls we can define client side (JavaScript) events in the aspx page. As on the server side, they will fire behind a certain event. We need to assign a function name that we are planning to execute on client side once the event is fired. Two parameters will be passed to our function, first is the control that generated the event (sender) and the event arguments. Each event and control has it’s own arguments. DevExpress controls are very function rich on client side, and you can consult the documentation to check all available client side events, functions and properties.

In the following Reference you can check the available client side functionality for the ASPxGridView. If you are interested in the other controls, just browse the interested control namespace that ends with Script.

In the page header (or in a separate .js file) define the following function:

<script type="text/javascript">
    function OnContextMenu(s, e) {
        if (e.objectType == 'row') {
            detailContextMenu.ShowAtPos(ASPxClientUtils.GetEventX(e.htmlEvent), ASPxClientUtils.GetEventY(e.htmlEvent));
        }
    }
</script>

In this function we will check if the context menu event is raised on a grid header or on the grid row. If it is a grid row we should popup a context menu. We can refer to the control on the client side by the ClientInstanceName that we defined for that control in the aspx file, this is done in this example. Each time you put a DevExpress control in your page, you will automatically have at your disposition an utility class called ASPxClientUtils containing several methods that can help you reducing your js code.

Now each time you right click the detail grid row, a context menu that you defined will be shown. What we are missing is the action that needs to be performed once the user chooses a context menu. In order to achieve this we need to add a client side event to our ASPxPopupMenu.

<dx:ASPxPopupMenu ID="detailContextMenu" runat="server" ClientInstanceName="detailContextMenu">
    <Items>
        <dx:MenuItem Name="cmdResetTest" Text="Reset Test" ToolTip="Reset Test to New Status">
        </dx:MenuItem>
    </Items>
    <ClientSideEvents ItemClick="detailContextMenu_ItemClick" />
</dx:ASPxPopupMenu>

There is some more work to do. As we are going to use a callback method of the detail grid to process the action on the server side, we need to find out the right detail grid that needs to be updated. In order to achieve so, we need to modify our previously defined method OnContextMenu.

<script type="text/javascript">
    var currentDetailGrid;
    var currentVisibleIndex;

    function OnContextMenu(s, e) {
        if (e.objectType == 'row') {
            currentDetailGrid = s;
            currentVisibleIndex = e.index;

            detailContextMenu.ShowAtPos(ASPxClientUtils.GetEventX(e.htmlEvent), ASPxClientUtils.GetEventY(e.htmlEvent));
        }
    }
</script>

What we did here is to save a reference to a detail grid and current visible index (row index on which the mouse was positioned when user right clicked) so we can reused it the Popup ItemClick event that we are going to define:

<script type="text/javascript">
    function detailContextMenu_ItemClick(s, e) {
        if (e.item.name == 'cmdResetTest') {
            currentDetailGrid.PerformCallback(currentVisibleIndex);
        }
    }
</script>

Once the menu item is chosen we will check if the item is the right one (this is useful if we have several items and we need to perform different actions based on chosen item) then request a callback for the grid on which user is operating right now. We will pass the current visible index as a parameter so we can spot the right element on which we are trying to apply our action. Before we can declare this server side event, we need to specify it in the aspx file:

<dx:ASPxGridView ID="gvDetail" runat="server" Width="100%" OnBeforePerformDataSelect="gvDetail_BeforePerformDataSelect"
    OnCustomCallback="gvDetail_CustomCallback" KeyFieldName="ID">

And than manage this event on the server side:

protected void gvDetail_CustomCallback(object sender, ASPxGridViewCustomCallbackEventArgs e)
{
    ASPxGridView grid = sender as ASPxGridView;

    int projectID = (int)grid.GetRowValues(int.Parse(e.Parameters), "ID");
    int currentUserID = (int)grid.GetMasterRowKeyValue();

    List<Project> projects = Users.Find(u => u.ID == currentUserID).Projects;
    projects.Find(p => p.ID == projectID).Status = ProjectStatus.New;

    grid.DataSource = projects;
    grid.DataBind();
}

As before, for simplicity we will cast the sender argument to ASPxGridView variable called grid. Then we will retrieve the ID of the project that was selected. The argument we passed before on the client side to the PerformCallback function will come handy right now as it will store the necessary data in order to find the interested project (by parsing the e.Parameters property). Next value we need to get is the user ID for which this detail grid is showing the associated projects. We can get it by a handy server side method GetMasterRowKeyValue() which will return a key value of the master grid (as you rememer we defined as a KeyFieldName the ID property of interested entities). Now, once we have the necessary data we can perform the desired actions and rebind the detail grid.

You can now add different actions in the Popup menu and manage them by passing a qualifier in the argument, parsing the argument and performing different operations. You will see this technique in my next blog post, stay tuned.

Programmatically disabling menu items

Unfortunately in this example the user can choose to reset the status of projects that are not in an invalid state. In order to disable the menu item if the state is not “resetable” we will need to make some changes in our code to pass more information to client side.
Before modifying the JavaScript, some considerations. In order to disable an item in the menu, we need to know the condition on which to do it. We can say that the Reset item needs to be disable when the project status is New. This status information we need to pass to the client side somehow. One way to achieve this is to store the status information together with the key value in a custom property. All the DeExpress controls have the possibility to easily add information from server side that will be brought and exposed on client side. This feature is called Custom Properties and you can find more information about them here. My technique is to save the Dictionary element to a custom property which will be seen as an array from JavaScript. All what I’m saying may sound confusing, so let’s see an real example.

First of all we will subscribe to OnHtmlRowCreated event. Modify the detail grid in the following way:

<dx:ASPxGridView ID="gvDetail" runat="server" Width="100%" OnBeforePerformDataSelect="gvDetail_BeforePerformDataSelect"
    OnCustomCallback="gvDetail_CustomCallback" OnHtmlRowCreated="gvDetail_HtmlRowCreated" KeyFieldName="ID">

Then write down the following code:

protected void gvDetail_HtmlRowCreated(object sender, DevExpress.Web.ASPxGridView.ASPxGridViewTableRowEventArgs e)
{
    if (e.RowType != GridViewRowType.Data) return;

    ProjectStatus status = (ProjectStatus)e.GetValue("Status");
    ASPxGridView grid = sender as ASPxGridView;

    if (grid.JSProperties.ContainsKey("cpStatus"))
    {
        Dictionary<int, ProjectStatus> values = (Dictionary<int, ProjectStatus>)grid.JSProperties["cpStatus"];

        if (values.ContainsKey(e.VisibleIndex))
        {
            values[e.VisibleIndex] = status;
        }
        else
        {
            values.Add(e.VisibleIndex, status);
        }

        grid.JSProperties["cpStatus"] = values;
    }
    else
    {
        Dictionary<int, ProjectStatus> values = new Dictionary<int, ProjectStatus>();
        values.Add(e.VisibleIndex, status);

        grid.JSProperties.Add("cpStatus", values);
    }
}

This code can seem complex but it isn’t. For each row that is going to be rendered I’m getting it’s visible index value, checking if I already have that value in my Dictionary type variable. If not, I’m adding a new item to my Dictionary together with it’s status. If changed, I’m persisting the new value to a custom JS property of the grid.
This means now that I can easily retrieve this information on client side. Modify your OnContextMenu function in the following way:

<script type="text/javascript">
    function OnContextMenu(s, e) {
        if (e.objectType == 'row') {
            var cmdResetTest = detailContextMenu.GetItemByName('cmdResetTest');
            cmdResetTest.SetEnabled(s.cpStatus[e.index] != 'New');

            currentDetailGrid = s;
            currentVisibleIndex = e.index;

            detailContextMenu.ShowAtPos(ASPxClientUtils.GetEventX(e.htmlEvent), ASPxClientUtils.GetEventY(e.htmlEvent));
        }
    }
</script>

We first need to retrieve the menu item then set the enable property based on custom JS property value.

That’s all, try your code, it should work.

Aesthetic changes

In order to make your solution look like mine, you will also need to set the theme and a couple of other properties that I will explain here.
First of all the theme. DevExpress control ships with a several themes, check the following web page for more details on how to deploy a theme to your solution. I applied the Acqua theme by importing the necessary files to my solution and changing the web.config in the following way (if not present add the following code inside the system.web section):

<pages theme="Aqua">
</pages>

I also added to both grids the title panel and the title itself:

<Settings ShowTitlePanel="True" />
<SettingsText Title="Master Grid / Detail for detail grid" />

In order to make a clicked row visually different I also enabled the AllowFocusedRow property. As it will set focus only on left mouse click, I also modified my JS OnContextMenu function, so it will get focused also on the right mouse click:

<script type="text/javascript">
    function OnContextMenu(s, e) {
        if (e.objectType == 'row') {
            s.SetFocusedRowIndex(e.index);
            var cmdResetTest = detailContextMenu.GetItemByName('cmdResetTest');
            cmdResetTest.SetEnabled(s.cpStatus[e.index] != 'New');

            currentDetailGrid = s;
            currentVisibleIndex = e.index;

            detailContextMenu.ShowAtPos(ASPxClientUtils.GetEventX(e.htmlEvent), ASPxClientUtils.GetEventY(e.htmlEvent));
        }
    }
</script>

The EnableRowHotTrack was also enabled so the grid displays the hot tracked row (a row located under the mouse pointer). You can read more about all these properties on DevExpress site.

Downloads and the source code

You can find the source code of my project for download here.
You can find a trial version of the requested controls here.

Notes and other resources

If a specific version of the controls is not available, you can upgrade this project to the latest version of controls. Use DevXperience Project Converter Tool for upgrading the project. Read more on how to use this tool in the following blog post.
You can find other examples on Master-Detail functionality on DevExpress site. This is Master-Detail – Detail Grid example, and the following is the usage of a tab control inside the detail row template.
In the DevExpress support site you will find several examples with the source code on different techniques this link will show you the solutions for a specific master-detail challenge.

‘Till the next post!

Cheers!

Voettekst

De eerste oorzaak kan zijn dat er ruimte wordt gemaakt onder een voettekst. Deze ruimte wordt vanaf de onderrand van de pagina ingesteld via Pagina-instelling – Indeling – Vanaf rand: Voettekst. Stel deze ruimte in op 0 cm om zo min mogelijk ruimte aan de onderkant van de pagina in te nemen.

Alinea-instellingen van de tekst na de tabel

Een tweede oorzaak is dat de tekst na de tabel (een etikettenvel bestaat uit één tabel) te veel ruimte inneemt. Stel deze in op Geen afstand voor en afstand na. Zelfs als er geen tekst na de tabel komt, staat er altijd minimaal één lege alinea na de tabel. Ga met Ctrl-End naar het eind van het document en stel via Alinea-Afstand voor en na in op 0 pt.

Lettertype-instellingen van de tekst na de tabel

Helpt dit niet? Stel dan ook de lettergrootte in op 1 pt.

Het gebeurt in een database regelmatig dat waarden moeten worden samengevoegd uit verschillende rijen. Bijvoorbeeld bij het maken van een kommagescheiden lijst van alle landen in een database. Tot voor kort gebruikte ik daar altijd COALESCE voor. Deze functie retourneert de eerste niet lege waarde van een reeks argumenten en COALESCE kan recursief in een query worden gebruikt als ook de mogelijkheid bestaat om variabelen in te zetten (maar dat is niet altijd mogelijk).

Voorbeeldtabel:

Ik heb een tabel met alle Europese landen  en een boolean waarde die aangeeft of ze momenteel (mei 2012) lid zijn van de Europese Unie.

Om nu met Coalesce een lijst van alle landen te maken die lid zijn gebruik:

DECLARE @EuroUnie NVARCHAR(MAX)
SELECT  @EuroUnie = COALESCE(@EuroUnie + ', ', '') + Land
FROM  tblLanden
WHERE  lid = 1
order by  Land

De uitkomst is:

België, Bulgarije, Cyprus, Denemarken, Duitsland, Estland, Finland, 
Frankrijk, Griekenland, Hongarije, Ierland, Italië, Letland, Litouwen, 
Luxemburg, Malta, Nederland, Oostenrijk, Polen, Portugal, Roemenie, 
Slovenië, Slowakije, Tsjechië, Verenigd Koninkrijk, Zweden

Ooit las ik ergens dat dit ook kan met XML, maar ik heb er eigenlijk nooit echt naar gekeken. Waarom XML inzetten als je geen XML nodig hebt? Tot ik op een dag een query nodig had die geen variabele kon gebruiken. Ik zocht de XML-variant op en tot mijn grote vreugde is die velen malen sneller. 23.000 records samenvoegen in een fractie van de tijd die COALESCE nodig heeft.

De code is wel wat lastiger te lezen, dus hierbij een uitleg stap voor stap.

Eerst de basisquery. Deze heeft weinig uitleg nodig.

select Land from tblLanden where lid=1 order by Land

Deze kan in XML worden gevangen door een for xml path toe te voegen

select Land from tblLanden where lid=1 order by Land for xml path('')

Doordat ik geen parameters specificeer bij path, zal SQL Server de naam van het veld gebruiken als XML naam:

<Land>België</Land><Land>Bulgarije</Land><Land>Cyprus</Land>
<Land>Denemarken</Land><Land>Duitsland</Land><Land>Estland</Land>
<Land>Finland</Land><Land>Frankrijk</Land><Land>Griekenland</Land>
<Land>Hongarije</Land><Land>Ierland</Land><Land>Italië</Land>
<Land>Letland</Land><Land>Litouwen</Land><Land>Luxemburg</Land>
<Land>Malta</Land><Land>Nederland</Land><Land>Oostenrijk</Land>
<Land>Polen</Land><Land>Portugal</Land><Land>Roemenië</Land>
<Land>Slovenië</Land><Land>Slowakije</Land><Land>Tsjechië</Land>
<Land>Verenigd Koninkrijk</Land><Land>Zweden</Land>

Maar als we het veld nu specifiek naar text() hernoemen, zal SQL server de xml names weglaten.

select  Land as [text()]  from tblLanden where lid=1 
order by Land for xml path('')

BelgiëBulgarijeCyprusDenemarkenDuitslandEstlandFinlandFrankrijk
GriekenlandHongarijeIerlandItaliëLetlandLitouwenLuxemburgMalta
NederlandOostenrijkPolenPortugalRoemeniëSloveniëSlowakijeTsjechië
Verenigd KoninkrijkZweden

Even wat spaties en komma’s toevoegen en we zijn er bijna.

select  ', ' + Land as [text()]  from tblLanden where lid=1 
order by Land for xml path('')

 , België, Bulgarije, Cyprus, Denemarken, Duitsland, Estland, Finland, 
Frankrijk, Griekenland, Hongarije, Ierland, Italië, Letland, Litouwen, 
Luxemburg, Malta, Nederland, Oostenrijk, Polen, Portugal, Roemenië, 
Slovenië, Slowakije, Tsjechië, Verenigd Koninkrijk, Zweden

De komma die ontstaat voor het eerste land, is niet moeilijk weg te werken. Eerst ga ik een ander issue oplossen. For XML geeft een XML datatype terug in plaats van een platte string. Dit kan opgelost worden met de functie Stuff. Deze functie plaatst een string in een andere string op een bepaalde positie.

select STUFF((select  ', ' + Land as [text()]  from tblLanden 
where lid=1 order by Land for xml path('')),1,1,'')

Met Stuff kan in het XML-resultaat het eerste karakter (de overtollige komma) worden vervangen met een lege string. Het resultaat is een string.

Deze techniek heeft in mijn database met miljoenen records keer op keer laten zien dat het een stuk sneller is dan COALESCE.

Why is it not a good idea to just create a folder Projects on a C drive and map everything under it? Well, this PC may be used by others, so this can cause security issues and it can also create confusion and problems if the new user chooses the same directory for mapping.

Based on this information, a good place where to store your code is the user folder. Generally you can find your user folder in C:\Users\%username% on Vista, Windows 7 and 8, C:\Documents and settings\%username% on XP and 2000. What I follow as a rule is to create a top folder called Projects and then inside that folder a sub folder for every collection I have access to. Supposing that my collection is called ACNProject the full path on my PC looks like C:\Users\mario.FLORES\Projects\ACNProject.

However in some cases this can be a problem. If you are using a roaming profile, you will need to do a couple of tweaks. You must exclude this newly create folder from synchronization and in order to be sure about that, you need to check the following registry key: HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\Winlogon\ExcludeProfileDirs. You will then find a similar content as on the following image:

Now you need to edit this key by adding at the end the folder name that is situated in Users directory, in this case Projects. Different folders are separated by a semicolon (;). If this became a company rule, you can avoid this step by applying the same changes via a group policy.
In case you do not have the rights for editing the registry and you are still using a roaming profile, a good place where to store the files can be C:\Documents and settings\%username%\AppData\Local which by default is never synced.

Now we are ready to map our collection. Open Visual Studio and Team Explorer.

Click on local path and fill in the above mentioned path. Make sure that you clicked on the collection folder (the $ sign will be visualized as a server folder) and that Recursive check is on. In this way for all the projects in that collection, automatically a folder will be created and mapping will have a recursive effect (all the projects in the collection will be automatically mapped).

Now you will be prompted about getting the latest version of all data from the server, choose No if there are many projects and you need a specific one and then get the latest version of that specific project, otherwise choose yes.

Certainly there can be a case that this approach will not fit, however I consider this a good practice. If you have any suggestions or comments, they are always welcome and I’m always ready to reconsider this task if anything meaningful pops up.

Cheers!