This just had this happen on a Windows 2003 server with a client’s client.

Any .asmx page would return a 404 error like this IIS log line shows:

2009-11-06 09:46:05 127.0.0.1 GET /MyVirtualDirectory/MyWebService.asmx – 80 – 127.0.0.1 Mozilla/4.0+(compatible;+MSIE+6.0;+Windows+NT+5.2;+SV1;+.NET+CLR+1.1.4322;+.NET+CLR+2.0.50727;+.NET+CLR+3.0.4506.2152;+.NET+CLR+3.5.30729) 404 2 1260

Searching for “iis 404 2 1260 asp.net” found this top from Marc Valk, that solved the issue: ASP.NET v2.0.5727 was prohibited to run.
Which means that none of the ASP.NET bound extensions would work: they all returned 404 errors.

(Note: if you are wondering where your IIS log files are, this post shows you).

–jeroen

The “out of the box” .NET 3.0 component in Windows XP Embedded drags way too many required components (like the System Restore Core) into your image.

So most people build their own .NET 3.0 component.

If you get errors like this when you make your own, then you didn’t get your dependencies right.

These are the dependencies for the .NET 3.0 framework:

• .NET Framework 2.0
• ASP.NET 2.0

These are the error messages you get when you forget the ASP.NET 2.0 dependency:

• ERROR_INSTALL_FAILURE 1603 Fatal error during installation

Of course I always get all my dependencies right
(yeah right, not this time)

–jeroen

I like enumerated type a lot.
The allow you to perfectly describe what the members of such a type actually mean, much more readable than a bunch of integer constants!

Given an enumerated type like TTraphicLightColors

type
  TTraphicLightColors = (Red, Orange, Green);

I always wondered why  - since the for ... in statement was added to the structured statements part of the Delphi language – it is not possible to use a for … in statement like the this:

</span>
<pre>var
  TraphicLightColor: TTraphicLightColors;
begin
  try
    for TraphicLightColor in TraphicLightColor do
      ShowValueAsTraphicLightColor(Ord(Value));
    // [DCC Error] EnumerationEnumeratorDemoProcedures.dpr(63): E2430 for-in statement cannot operate on collection type 'TTraphicLightColors'
end;

Somehow, for … in expects a collection type.
A request for the for … in do on enumerated types compiler feature is in QC, but it is closed with reason “Won’t do”.

Back in Delphi 2007, I tried working around this by writing a type implementing the GetEnumerator pattern myself, but got Internal Errors when compiling anything but the most basic sample.

Until today, where I found how I could get that most basic sample to work!
It is an example on how you could implement this: it is research, so you decide if you find the result practical enough to use yourself.

Lets start with the REnumerationEnumerator record and the TEnumerationEnumerator enumerator class that it generates:

unit EnumerationEnumerator;

interface

uses
  TypInfo;

type
  TEnumerationEnumerator = class
  private
    FMinValue: Integer;
    FMaxValue: Integer;
    FValue: Integer;
  public
    constructor Create(aEnumeratorTypeInfo: PTypeInfo);
    function GetCurrent: Integer;
    function MoveNext: Boolean;
    property Current: Integer read GetCurrent;
  end;

  REnumerationEnumerator = record
  private
    EnumeratorTypeInfo: PTypeInfo;
  public
    constructor Create(aEnumeratorTypeInfo: PTypeInfo);
    class function From(aEnumeratorTypeInfo: PTypeInfo): REnumerationEnumerator; static;
    function GetEnumerator: TEnumerationEnumerator;
  end;

implementation

{ REnumerationEnumerator }

constructor REnumerationEnumerator.Create(aEnumeratorTypeInfo: PTypeInfo);
begin
  Assert(aEnumeratorTypeInfo^.Kind = tkEnumeration);
  EnumeratorTypeInfo := aEnumeratorTypeInfo;
end;

{ REnumerationEnumerator }

class function REnumerationEnumerator.From(aEnumeratorTypeInfo: PTypeInfo): REnumerationEnumerator;
begin
  Result := REnumerationEnumerator.Create(aEnumeratorTypeInfo);
end;

function REnumerationEnumerator.GetEnumerator: TEnumerationEnumerator;
begin
  Result := TEnumerationEnumerator.Create(EnumeratorTypeInfo);
end;

{ TEnumerationEnumerator }

constructor TEnumerationEnumerator.Create(aEnumeratorTypeInfo: PTypeInfo);
var
  EnumeratorTypeInfo: PTypeInfo;
  EnumerationTypeData: PTypeData;
begin
  Assert(aEnumeratorTypeInfo^.Kind = tkEnumeration);
  EnumeratorTypeInfo := aEnumeratorTypeInfo;
  EnumerationTypeData := GetTypeData(EnumeratorTypeInfo);
  FMinValue := EnumerationTypeData.MinValue;
  FMaxValue := EnumerationTypeData.MaxValue;
  FValue := FMinValue-1;
end;

function TEnumerationEnumerator.GetCurrent: Integer;
begin
  Result := FValue;
end;

function TEnumerationEnumerator.MoveNext: Boolean;
begin
  Result := FValue < FMaxValue;
  if Result then
    Inc(FValue);
end;

end.

Note it contains both a Create constructor and From static class function.
This is by intent, I will explain this shortly.

The above unit gets great result when you call it in the main body of a simple console application like this:

program EnumerationEnumeratorDemo;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  TypInfo,
  EnumerationEnumerator in 'EnumerationEnumerator.pas',
  TraphicLightColorsUnit in 'TraphicLightColorsUnit.pas';

procedure ShowValueAsTraphicLightColor(Value: Integer);
var
  TraphicLightColorsTypeInfo: PTypeInfo;
begin
  TraphicLightColorsTypeInfo := TypeInfo(TTraphicLightColors);
  Writeln(Value, ' ', GetEnumName(TraphicLightColorsTypeInfo, Value));
end;

var
  Value: Integer;
  TraphicLightColor: TTraphicLightColors;
  TraphicLightColorsTypeInfo: PTypeInfo;
begin
  try
    Writeln('For in - create constructor - only works in your main program:');
    TraphicLightColorsTypeInfo := TypeInfo(TTraphicLightColors);
    for Value in REnumerationEnumerator.Create(TraphicLightColorsTypeInfo) do
    begin
      // TraphicLightColor := TTraphicLightColors(Value);
      ShowValueAsTraphicLightColor(Value);
    end;

    Writeln('For to:');
    for TraphicLightColor := Low(TTraphicLightColors) to High(TTraphicLightColors) do
    begin
      Value := Ord(TraphicLightColor);
      ShowValueAsTraphicLightColor(Value);
    end;

    Write('Press <Enter>');
    Readln;
  except
    on E:Exception do
      Writeln(E.Classname, ': ', E.Message);
  end;
end.

You get output like this:

For in – create constructor – only works in your main program:
0 Red
1 Orange
2 Green
For to:
0 Red
1 Orange
2 Green
Press

Until you start using that code in a procedure or function, then you consistently get Internal Error messages from the compiler.
The exact Internal Error is always of type F2084, but the subtype depends on the version of Delphi you have installed:

procedure ForIn_InternalCompilerError;
var
  Value: Integer;
  TraphicLightColorsTypeInfo: PTypeInfo;
begin
  TraphicLightColorsTypeInfo := TypeInfo(TTraphicLightColors);
  for Value in REnumerationEnumerator.Create(TraphicLightColorsTypeInfo) do
    ShowValueAsTraphicLightColor(Value);
end;
// Delphi 2007:
// [DCC Error] EnumerationEnumeratorDemoProcedures.dpr(49): F2084 Internal Error: C14125
// Delphi 2009:
// [DCC Error] EnumerationEnumeratorDemoProcedures.dpr(49): F2084 Internal Error: C15170
// Delphi 2010:
// [DCC Error] EnumerationEnumeratorDemoProcedures.dpr(49): F2084 Internal Error: C15700

Bummer. It actually caused me too loose interest in using for … in with enumerated types for a while.
Until today, when I needed a static class function returning an instance of another type.
Then I realized that there is not much difference between a constructor, and such function.

So in addition to the Create constructor, I added a From function like this:

    constructor Create(aEnumeratorTypeInfo: PTypeInfo);
    class function From(aEnumeratorTypeInfo: PTypeInfo): REnumerationEnumerator; static;

Lo and behold, this code now compiles fine:

procedure ForIn;
var
  Value: Integer;
  TraphicLightColorsTypeInfo: PTypeInfo;
begin
  TraphicLightColorsTypeInfo := TypeInfo(TTraphicLightColors);
  for Value in REnumerationEnumerator.From(TraphicLightColorsTypeInfo) do
    ShowValueAsTraphicLightColor(Value);
end;

This finally creates a work around the Internal Errors mentioned in QC65594.

I’m still a bit puzzled why this works with a static class function, but not with a constructor.
If anyone has a clue about that, please drop a note below.

–jeroen

Operator overloading is a very nice feature of the Delphi language.
However. the Delphi documentation on Operator overloading is not completely right.

Below is my table of what I found out so far, and some notes.

It is part of my “Nullable types in Delphi” session that I gave on some conferences.
The downloads for that session contain more detailed information.

This is just an abstract to get you going and a try to answer this operator overloading question on Stackoverflow.
Download the full presentation to get more in depth information.

Let me know if you need more information.

Notes

Operator overloading

Add your own “behaviour” to operators

• Win32: Works only for records, not classes!
• An operator and the operand(s)
  are being implemented worden by a “class operator”;
  this is a kind of class method with name and argumen(s)

Example:

• Multiplication X : = A * B;
• Operator: *
• Name: Multiply
• Operands: 2 -> two parameters

type
  TMyRecord = record
    class operator Multiply(A, B: TMyRecord): TMyRecord;
  end;

Documentation is not correct!

• http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/devcommon/operatoroverloads_xml.html
• http://docwiki.embarcadero.com/RADStudio/en/Operator_Overloading
• Win32 only records; .NET classes and records
• BitwiseNot does not exist (use LogicalNot)
• At least 1 operand must be of the same type as your record data type
• Result type may be anything

Watch the result type of comparison operators!

Tips:

• Some operators should be overloaded pair-wise
  = and <>
  shl and shr
  < and >=
  > and <=
  dec and inc
  + and -
  / and *
  div and mod
• Prefer Explicit over Implicit operators
  • Beware of the built-in type coercion (implicit operators)
  • e.g
    • Byte to Integer;
    • Integer to Double;
    • Variants from/to anything!

Table of operators

–jeroen

There are quite a few registry tricks that you can perform to influence the Delphi IDE.

If you have any registry settings to share, please let me know by posting a comment below, or filling out the contact form.

This summary will be enhanced over time:

• 20091015 – Chris Bensen – Delphi Tips and Tricks – Additional Files
• 20090509 – René Rikkers - Delphi 2009 broken after installing Update 2
• 20080912 - Matthias Eissing - C++ Builder 2007 und der Remote Debugger
• 20071017 – Chris Bensen – Delphi and C++ Builder IDE Memory Usage Tip
• 20070928 - Sergio Cardoso - Are you nuts?
• 20070920 - David Clegg - Maximizing your RAD Studio 2007 experience
• 20070509 - Fredrik Haglund - How do I get my application with Paradox tables to work on Windows Vista?
• 20070313 – Chris Hesik – Source has been modified. Rebuild?
• 20061019 - Steve Trefethen - IE7 is now available get your BDS reg file here
• 20060110 – Mark Edington – Delphi Startup Times and the Kitchen Sink
• 20051219 - Adam Markowitz - Displaying macros in Code Completion (C++Builder2006)
• 20051209 – Adam Markowitz – Hidden feature, anyone?! (Delphi2006)
• 20051208 - Chris Hesik - BDS 2006 Debugger and .NET 2.0 compatibility
• 20040929 – Corbin Dunn – Delphi 8 Tips, Tricks and Speed Improvements
• 20040923 - Allen Bauer - Newsgroups leakage…
• 20041228 – Daniel Polistchuck – Delphi 2005 and Janeva 6.5
• 20040313 - Allen Bauer - Revenge of the Automated IDE Incident reporting
• 20040217 – Allen Bauer – Delphi 7 packages for using the Delphi 8 Win32 compiler
• 20031029 – Allen Bauer – Editor pair highlighting

Have fun with them!

–jeroen

Finding the correct VERxxx conditional define for a particular Delphi version is asked by a lot of people.

Even the first link in the above search, does not contain the full list!
But: JCL comes to the rescue

The JCL file JEDI.INC usually (read: like 99.999% of the time) is up to that with that information soon.
Currently, it contains all the defines starting with Delphi 1, up to Delphi 2010.

You can always browse the to JEDI.INC with this link to the sourceforge trunk.

In fact that file contains a lot more useful defines.
Actually, having the JCL and/or JVCL at hand is a very good practice: it is filled with high quality code that solves a lot of everyday problems.

Note:

VER190 (by some people attributed to the wrong Delphi version) is only used by Delphi 2007 for .NET (Delphi 2007 for Win32 used VER185 by itself and shares VER180 with Delphi 2006 for Win32).

The number 13 (in between Delphi 2009 aka Delphi 12, and Delphi 2010 aka Delphi 14) was never used as a Delphi version number
Since Delphi is mainly developed in the USA, and since a lot people there have Triskaidekaphobia, they showed mercy to those and skipped Delphi 13.

–jeroen

Recently we got involved with a client having a large and complex application that (historically) consists of

1. A main .EXE that loads
2. Many DLLs
3. Underlying BPLs

One of the biggest problems is debugging the startup sequence.
Somehow, when the Delphi IDE loads DLLs in the initialization sequences of units, it looses its ability symbol tables.

This article describes a few tips on how to debug those, especially where to put breakpoints.

Yes, we have done the obvious things like:

• the EXE, DLLs and BPLs were already in the same directory
• that directory is referenced in the IDE Debug symbol search path for loading the symbols
• turned on all sorts of debug information (Turbo Debugger inside EXE/DLL/BPL, RSM files, MAP files)
• turned off Optimization and turned on Stack frames
• and studied a lot of FAQs and tips from other people

In the end, it appears that when DLL’s with symbols get loaded during unit initialization sections, the Delphi IDE (in this case 2007) loses the Symbol Tables either for the EXE or for the DLL (or both).

In order to work around this:

• We had to know which DLLs were loaded and when
• We rewrote all the DLLs to be ‘demand/delay loaded‘ (i.e. not statically linked, see code sample below)
• We rewrote all the stuff that referenced the DLLs to initialize on demand as well

Here are some tips for setting breakpoints to debug the startup sequence, including some links to relevant documentation, samples or articles:

1. Unit System; procedure InitUnits; line “TProc(P)();”
   (this line gets called often: for each unit that is being initialized, either because the unit has an initialization section, or it has initialized consts; see an example call stack) .
2. Unit SysUtils; procedure SafeLoadLibrary;
   (we call this for every DLL that gets loaded; this method saves and restores the FPU control word, especially handy for 3rd party DLLs that think they own the FPU).
3. unit System; procedure _InitLib; line “MOV EDX,offset Module”
   (this gets called in a DLL when Windows is loading it with LoadLibrary)
4. unit SysInit; procedure InitProcessTLS;
   (inside a DLL this reserves the Thread Local Storage to be used by this DLL; it usually is the first thing called in a DLL)
5. unit System; procedure ExitDll; line “RET 12″ (assembler)
   (this gets called in a DLL when Windows is almost finished processing the LoadLibrary for it)
6. DLL kernel32.LoadLibraryA and DLL kernel32.LoadLibraryW, CPU code “cmp dword ptr [ebp+$08],$00″, then in the data portion of the CPU viewer, go to the address “ebp+$08″ , then press Ctrl-D to follow “long data”; now you see the module that is going to be loaded
   (this gets called by Windows when loading DLLs)
7. ntdll.LdrInitializeThunk, CPU code “call dword ptr[ebp+$08]“
   (this gets called by Windows just before loading the DLL)

For the demand loading, we used this small unit:

unit BLibrary;

interface

uses
  SysUtils, Windows;

const
  NoLibraryHandle = 0;

type
  ELibrary = class(Exception);
  TLibraryRecord = record
    Name: string;
    Handle: HModule;
  end;

  /// See also this method in the ComObj unit:
  /// procedure RegisterComServer(const DLLName: string);
function LoadLibrary(var LibraryRecord: TLibraryRecord): Boolean; overload;

procedure FreeLibrary(var LibraryRecord: TLibraryRecord); overload;

function GetProcAddress(var LibraryRecord: TLibraryRecord; const ProcName: string): FARPROC; overload;

implementation

function IsInvalidModuleHandle(const Handle: HModule): Boolean;
begin
  Result := (Handle <= HINSTANCE_ERROR);
end;

function SysErrorMessageLastError(): string;
begin
  Result := SysErrorMessage(GetLastError);
end;

function LoadLibrary(var LibraryRecord: TLibraryRecord): Boolean;
begin
  Result := False;
  if IsInvalidModuleHandle(LibraryRecord.Handle) then
  begin
    LibraryRecord.Handle := SafeLoadLibrary(LibraryRecord.Name);
    if IsInvalidModuleHandle(LibraryRecord.Handle) then
      raise ELibrary.CreateFmt('DLL "%s" nicht geladen wegen: "%s"',
        [LibraryRecord.Name, SysErrorMessageLastError]);
    Result := True;
  end;
end;

procedure FreeLibrary(var LibraryRecord: TLibraryRecord);
var
  Success: Boolean;
begin
  if not IsInvalidModuleHandle(LibraryRecord.Handle) then
  begin
    Success := Windows.FreeLibrary(LibraryRecord.Handle);
    if not Success then
      raise ELibrary.CreateFmt('DLL "%s" entladen fehler: "%s"',
        [LibraryRecord.Name, SysErrorMessageLastError]);
    LibraryRecord.Handle := NoLibraryHandle;
  end
end;

function GetProcAddress(var LibraryRecord: TLibraryRecord; const ProcName: string): FARPROC;
begin
  LoadLibrary(LibraryRecord);
  Result := Windows.GetProcAddress(LibraryRecord.Handle, PChar(ProcName));
  if Result = nil then
    raise ELibrary.CreateFmt('DLL "%s" fehler beim laden von ohne Eintrittspunkt "%s": "%s"',
      [LibraryRecord.Name, ProcName, SysErrorMessageLastError]);
end;

end.

This article is work-in-progress, so you will see updates in the next coming days.

–jeroen

Jolyon Smith just published a great article about using the absolute keyword in Delphi.

When used with care (just like the with or goto keywords), absolute can make your code much easier to maintain.

Recommended reading!

–jeroen

I found back one of my earliest mail messages: it is dated back in februari 1989.

Wow – ain’t search engines nice!

Today, messages like those seem totally irrelevant.

But back then, getting in touch with other people through email could be a real challenge.

The internet was forming (out of UUNET, DECnet, BITNET, Usenet, EARN, ARPANET and others), and not everything was completely interconnected yet, let alone connected on-line 24/7.
For instance, newsgroups were limited to the usenet portion of the internet, and not available on the bitnet portion.

So, mail and mailing lists were the prevalent means of communication: LISTSERV was the first program facilitating mailing lists.

Routing mail could be a challenge as well.
There was not yet such a widespread thing as SMTP or POP3 as it is today.
So mail got relayed (in fact open mail relays were the standard configuration), and often you had to provide the routing instructions in your mail as well.

Hence the complicated mail addresses used in the message linked above.

Back then, on the for sending mail on the on the VAX/VMS I was working on, gMail (note the spelling) was a very good mail program that would magically do most of the routing for you.

BITNIC used to be a repository to download information and programs.

UUENCODE one of the early encoding schemes to send binaries over email (and still one of Microsoft’s email programs barfs when you put ‘begin 664′ at the beginning of a line).

BITNET Relay was one of the earliest chat programs (much like IRC now), and HEARN the mean node in The Netherlands.

History is fun!

–jeroen

Recently, I had to change the “Password Never Expires” flag for some users on Windows systems.

In the past, there used to be a netuser tool available from WindowsITPro where you could use the pwnexp flag to set or clear that flag.
That tool seems to be vanished, so I was searching for alternatives.

Most alternatives I found depend on some  kind of scripting, or the use of the WMIC WMI command line interface: that was “out” because this particular setup is running on Windows XP Embedded, which is trimmed down very much.
The only C# example I found was on CodeProject, but it does

• not take into account the existing flags correctly,
• have  hard coded literals without any references where they are from,
• use bit flag arithmetic without letting the C# compiler do its magic with enums,
• use a call to the deprecated  InvokeGet method,
• use the Invoke(“Put”, … way of calling that so many people use (which actually should have been an – also deprecated – InvokeSet method),
• use COM Interop

Hence the solution below:
C#, with the proper ADS_USER_FLAG_ENUM enum from the MSDN documentation and no COM Interop, it also moves all literals to constants.

This example does not use any Interop, but it

• requires the System.DirectoryServices.dll assembly (which ships with .NET 2.0 and up),
• uses the System.DirectoryServices namespace,
• and from there the DirectoryEntry class with the Properties property

With those, it becomes more readable, easier to debug and therefore a lot more maintainable.

Note that this code needs full trust security.
In my case that is not a problem, as this code executes while building the Windows XP Embedded image.

        // see http://msdn.microsoft.com/en-us/library/aa772300(VS.85).aspx
        [Flags]
        enum ADS_USER_FLAG_ENUM
        {
            ADS_UF_SCRIPT = 1,         // 0x1
            ADS_UF_ACCOUNTDISABLE = 2,         // 0x2
            ADS_UF_HOMEDIR_REQUIRED = 8,         // 0x8
            ADS_UF_LOCKOUT = 16,        // 0x10
            ADS_UF_PASSWD_NOTREQD = 32,        // 0x20
            ADS_UF_PASSWD_CANT_CHANGE = 64,        // 0x40
            ADS_UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED = 128,       // 0x80
            ADS_UF_TEMP_DUPLICATE_ACCOUNT = 256,       // 0x100
            ADS_UF_NORMAL_ACCOUNT = 512,       // 0x200
            ADS_UF_INTERDOMAIN_TRUST_ACCOUNT = 2048,      // 0x800
            ADS_UF_WORKSTATION_TRUST_ACCOUNT = 4096,      // 0x1000
            ADS_UF_SERVER_TRUST_ACCOUNT = 8192,      // 0x2000
            ADS_UF_DONT_EXPIRE_PASSWD = 65536,     // 0x10000
            ADS_UF_MNS_LOGON_ACCOUNT = 131072,    // 0x20000
            ADS_UF_SMARTCARD_REQUIRED = 262144,    // 0x40000
            ADS_UF_TRUSTED_FOR_DELEGATION = 524288,    // 0x80000
            ADS_UF_NOT_DELEGATED = 1048576,   // 0x100000
            ADS_UF_USE_DES_KEY_ONLY = 2097152,   // 0x200000
            ADS_UF_DONT_REQUIRE_PREAUTH = 4194304,   // 0x400000
            ADS_UF_PASSWORD_EXPIRED = 8388608,   // 0x800000
            ADS_UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION = 16777216   // 0x1000000
        } ;

        /// <summary>
        /// Sets or clears the "Password Never Expires" flag for a user on the current system.
        /// This is based on ideas in http://www.codeproject.com/KB/system/OSUserMangement.aspx,
        /// but not that the code there is wrong: it does not take into account the current userFlags value
        /// The code below does take that into account and is much more maintainable.
        ///
        /// the logic can be made a bit easier by applying sets
        /// </summary>
        /// <param name="userName">name of the user to set the Password Never Expires flag</param>
        /// <param name="passwordNeverExpires">new flag value</param>
        protected virtual void setPasswordNeverExpires(string userName, bool passwordNeverExpires)
        {
            const string userNameString = "userName";
            const string userFlagsString = "userFlags";

            string machineName = Environment.MachineName;

            DirectoryEntry userInThisComputerDirectoryEntry = getUserInThisComputerDirectoryEntry(machineName, userName);
            if (null == userInThisComputerDirectoryEntry)
                throw new ArgumentException("not found in " + machineName, userNameString);

            PropertyValueCollection userFlagsProperties = userInThisComputerDirectoryEntry.Properties[userFlagsString];

            ADS_USER_FLAG_ENUM userFlags = (ADS_USER_FLAG_ENUM)(userFlagsProperties.Value);
            ADS_USER_FLAG_ENUM newUserFlags = userFlags;

            if (passwordNeverExpires)
                newUserFlags = newUserFlags | ADS_USER_FLAG_ENUM.ADS_UF_DONT_EXPIRE_PASSWD;
            else
                newUserFlags = newUserFlags & (~ADS_USER_FLAG_ENUM.ADS_UF_DONT_EXPIRE_PASSWD);

            userFlagsProperties.Value = newUserFlags;

            userInThisComputerDirectoryEntry.CommitChanges();
        }

        protected virtual DirectoryEntry getUserInThisComputerDirectoryEntry(string machineName, string userName)
        {
            DirectoryEntry computerDirectoryEntry = getComputerDirectoryEntry(machineName);

            const string userSchemaClassName = "user";
            return computerDirectoryEntry.Children.Find(userName, userSchemaClassName);
        }

        protected virtual DirectoryEntry getComputerDirectoryEntry(string machineName)
        {
            //Initiate DirectoryEntry Class To Connect Through WINNT Protocol
            // see: http://msdn.microsoft.com/en-us/library/system.directoryservices.directoryentry.path.aspx
            const string pathUsingWinNTComputerMask = "WinNT://{0},computer";
            string path = string.Format(pathUsingWinNTComputerMask, machineName);
            DirectoryEntry thisComputerDirectoryEntry = new DirectoryEntry(path);
            return thisComputerDirectoryEntry;
        }

This code is just an example on how you can do it in a maintainable way.
It can easily be extended to other properties as well.

–jeroen