Use BeginUpdate and EndUpdate to increase performance of Delphi Visual / Design Components

Use BeginUpdate and EndUpdate to increase performance of Delphi Visual / Design Components

If you are using Delphi visual / design components like a ListBox, Memo, TreeList, ListView, DataView etc. and you add or modify a lot of items (lines, nodes etc.), the component's performance becomes very slow. This is due to the fact that after each change, it is redrawn on the screen.

Thus, modifying 10000 items of a ListBox causes 10000 redraws, and that takes from several seconds to several minutes, depending on the computer's speed and the complexity of the process. Imagine how slow it can become if the process involves inserting, deleting, modifying and swapping many thousands of items. But you can speed up things enormously with the following tip:

Call BeginUpdate before making the changes to the items. When all changes are complete, call EndUpdate to show the changes on screen. BeginUpdate and EndUpdate prevent excessive redraws and speed up processing time when items are added, deleted, or inserted.

Using BeginUpdate and EndUpdate is an implementation of the lock and unlock pattern in Delphi. It allows you to you temporarily lock an aspect of the class, avoiding unneeded notifications.

Here's a simple source code example for using this technique with a ListBox:

ListBox1.Items.BeginUpdate;

for i := 1 to 10000 do

    ListBox1.Items.Add('abcd');

ListBox1.Items.EndUpdate;

To give you an idea of the improvement, we timed the code above (your PC may be faster or slower):

without the BeginUpdate/EndUpdate lines: 4.3 seconds...

with BeginUpdate/EndUpdate: 0.1 seconds, that's 43 times faster!

Here's a source code example for using this technique with a Memo:

Memo1.Lines.BeginUpdate;

for i := 1 to 5000 do

    Memo1.Lines.Add('abcd');

Memo1.Lines.EndUpdate;

without BeginUpdate/EndUpdate: 25 seconds...

with BeginUpdate/EndUpdate: 0.6 seconds!

Example with Panels

The following example adds a panel to the status bar control when the user clicks the button and adds a caption to the panel. The code uses BeginUpdate and EndUpdate to prevent repaints until the operation is complete. A try...finally block ensures that EndUpdate is called even when an exception occurs.

procedure TForm1.Button1Click(Sender: TObject);

var

  PanelIndex : Integer;

begin

  with StatusBar1 do

  begin

    Panels.BeginUpdate;

    PanelIndex := StatusBar1.Panels.Count - 1;

    try

      Panels.Add;

      Inc(PanelIndex);

      Panels.Items[PanelIndex].Text := 

        'Panel' + IntToStr(PanelIndex);

    finally

      Panels.EndUpdate;

    end;

  end;

end;

Locking and Unlocking mechanism in Delphi

Locking and Unlocking mechanism in Delphi

This article provides a mechanism to temporarily lock and unlock some aspects of a class. We will discuss locking and unlocking patterns in Delphi with a simple example.

Often you’ll find that a object dispatches notifications as a result of changing it’s internal state. Clients will handle these notifications to synchronise with the object. If multiple changes are to be applied at once, this will result in multiple notifications and subsequent synchronisations. The lock pattern let’s you temporarily lock an aspect of the class, avoiding unneeded notifications. Locking can be applied nested.

Consider for example a TBag class which implements collection like behaviour. TBag dispatches an OnChange event each time something changes. If we wanted to add multiple objects to a bag, this would result in multiple change notifications. A GUI control wiring the OnChange event would have to be repainted each time, resulting in a poor performance. The lock pattern enables locking the bag before adding the objects. When the objects are added, the bag is unlocked again, which will result in a single dispatch of OnChange. The advantage of using a lock pattern rather than setting a Boolean flag, for example FUpdating, is that calls to Lock and Unlock can be nested.

Implementation

The implementation for the lock pattern applied to a class TBag is: (only pattern related code is shown)

type 

  TBag = class (TObject) 

  private 

    FLockCnt: Integer; 

  protected 

    function Locked: Boolean; 

    procedure SetLocking(Updating: Boolean); 

  public 

    procedure Lock; 

    procedure UnLock; 

  end;

implementation

procedure TBag.Lock; 

begin 

  Inc(FLockCnt); 

  if FLockCnt = 1 then SetLocking(False); 

end;

function TBag.Locked: Boolean; 

begin 

  Result := (FLockCnt <> 0); 

end;

procedure TBag.SetLocking(Updating: Boolean); 

begin 

end;

procedure TBag.UnLock; 

begin 

  Dec(FLockCnt); 

  if FLockCnt = 0 then SetLocking(True); 

end;

In this implementation notice: The field FLockCnt which stores the state of the locking mechanism. FLockCnt = 0 represents an unlocked state. Any other value implicates a locked state. This allows nested calls to Lock and Unlock which are the only methods changing this field. The methods Lock and Unlock which provide the locking interface. Each time a call to one of these methods causes a locked state change, method SetLocking is called. Method SetLocking has one parameter Updating. If Updating is True, the bag has become unlocked due to a call to Unlock. If Updating is False, the bag has become locked due to a call to Lock. You would typically insert some code in this method which deals with the lock state change. Method Locked returns the state of the locking mechanism.

Notice how calls to Lock and Unlock always must be paired to avoid the Bag to remain locked forever. Therefore it is wise to use a try..finally block to make sure pairs are always matched, as is demonstrated in the following example.

A typical use of the lock mechanism would be:

procedure TBag.Add(Item: Pointer); 

begin 

  { Add Item to internal structure } 

  Change; 

end

procedure TBag.AddItems(Items: TList); 

begin 

  Lock; 

  { Add multiple items } 

  try 

    for I := 0 to Items.Count - 1 do 

      Add(Items[I]); 

  finally 

    { use try..finally to make sure Unlock is called } 

    Unlock; 

  end; 

end;

procedure TBag.Change; 

begin 

  if not Locked then 

    if Assigned(FOnChange) then FOnChange(Self); 

end;

procedure TBag.SetLocking(Updating: Boolean); 

begin 

  if Updating then { Bag has become unlocked } 

    Change; 

end;

Since this mechanism can be used in many situations, the lock patterns let’s you edit the patterns field and method names. This pattern is one of the few patterns that can be applied to the same class more than once and still be meaningful. You would of course need different names, such as LockUpdate, LockScreenUpdate or BeginUpdate.

Difference between Unicode, UTF-8 and UTF-16 (Unicode vs UTF-8 vs UTF-16)

Difference between Unicode, UTF-8 and UTF-16 (Unicode vs UTF-8 vs UTF-16)

Unicode is a character set. UTF-8 and UTF-16 are both encodings of Unicode. 

A character set is a list of characters with unique numbers (these numbers are sometimes referred to as "code points"). For example, in the Unicode character set, the number for A is 41.

An encoding on the other hand, is an algorithm that translates a list of numbers to binary so it can be stored on disk. For example UTF-8 would translate the number sequence 1, 2, 3, 4 like this:

00000001 00000010 00000011 00000100 

Our data is now translated into binary and can now be saved to disk.

All together now

Say an application reads the following from the disk:

1101000 1100101 1101100 1101100 1101111 

The app knows this data represent a Unicode string encoded with UTF-8 and must show this as text to the user. First step, is to convert the binary data to numbers. The app uses the UTF-8 algorithm to decode the data. In this case, the decoder returns this:

104 101 108 108 111 

Since the app knows this is a Unicode string, it can assume each number represents a character. We use the Unicode character set to translate each number to a corresponding character. 

The resulting string is "hello".

Historical Artifact from Microsoft

The development of Unicode was aimed at creating a new standard for mapping the characters in a great majority of languages that are being used today, along with other characters that are not that essential but might be necessary for creating the text. UTF-8 is only one of the many ways that you can encode the files because there are many ways you can encode the characters inside a file into Unicode.

UTF-8 was developed with compatibility in mind. ASCII was a very prominent standard and people who already had their files in the ASCII standard might hesitate in adopting Unicode because it would break their current systems. UTF-8 eliminated this problem as any file encoded that only has characters in the ASCII character set would result in an identical file, as if it was encoded with ASCII. This allowed people to adopt Unicode without needing to convert their files or even changing their current legacy software that was unaware of the Unicode standard. Any of the other mapping methods for Unicode breaks compatibility with ASCII and would force people to convert their system.

The observance of compatibility to ASCII of UTF-8 produces a side-effect that makes it ideal for word processing where most of the time, all the characters being used are included in the ASCII character set. UTF-8 only uses a byte to represent every code point resulting in a file size that is half to the same file encoded in UTF-16 which uses 2 bytes, and a quarter to the same file encoded in UTF-32 which uses 4.

UTF-8 has been adopted in the World Wide Web because it is both space efficient and byte oriented. Web pages are often simple text files that usually do not contain any character that is outside the ASCII character set. Using other encoding methods would only increase the network load without any benefit. Even in email transport systems, UTF-8 is slowly but surely being adopted as a replacement for the older encoding systems that are still being used.

Summary:

1. Unicode is the standard for computers to display and manipulate text while UTF-8 is one of the many mapping methods for Unicode. 

2. UTF-8 is a mapping method the retains compatibility with the older ASCII

3. UTF-8 is the most space efficient mapping method for Unicode compared to other encoding methods

4. UTF-8 is the most used Unicode standard for the web

Conclusion

UTF-8 and Unicode cannot be compared. UTF-8 is an encoding used to translate binary data into numbers. Unicode is a character set used to translate numbers into characters.

Very Important Last Interview Question: Do you have any question for me?

Very Important Last Interview Question: Do you have any question for me?

If you are going for any interview, you must know that at the end of the interview, after asking many questions from you, the interviewer will allow you to ask questions from him. Last question of the interview will be: "Do you have any question for me?". And, my advice is that you must prepare this very last question beforehand.

When the interviewer asks if the candidate has any questions and the answer is none it can be perceived as a low interest level in taking up the job offered.

The questions by the candidate should show a sound knowledge of the company and the overall responsibilities of the offered position. A confident candidate would always want to know more about the organization, in terms of work culture, growth prospects, organizational values, team work and an inside view of the job profile.

The following are the questions the interviewer would be happy to hear from an interviewee, because the interviewer feels this would be what a clear thinking, success oriented candidate would want to know.

Below is the list of the questions you must prepare to ask from interviewer at the end of the interview:

1. Is your company growing and what are the prospects of future expansion?

2. What difficulties do new employees experience in adapting to your company's environment?

3. What are the primary success factors of this role?

4. Might there be other ways I can contribute to the business with my skill sets?

5. Should I be successful, what are the opportunities for advancement?

6. What should I expect with regard to feedback?

7. Will I have an opportunity to create a development plan to be coached on throughout the year?

8. What emphasis is placed on teams working together?

26 A-Z Small but Important Tips for Cracking your Job Interview

26 A-Z Small but Important Tips for Cracking your Job Interview

Are you preparing for your job interview in your dream company? Best of luck!! Following are 26 small but important job interview tips arranged in alphabetical order from A to Z. Please go through all job interview tips once before appearing for any interview in any field for any position.

A – Anticipate key questions and have answers ready 

B – Bring the information you will need to fill out an application (references, dates, Social Security Number, etc.) 

C – Connect your past work experience to the present position you are interviewing for 

D – Don’t criticize your previous employer; it will leave a bad impression 

E – Eye contact with the interviewer shows confidence 

F – Fill in all blanks on the application (except the salary blank) 

G – Get there 15-20 minutes early; NEVER be late! 

H – Handshake should be firm 

I – Incorporate specific examples of your successes 

J – Job responsibilities that you excelled at in your past experience should be discussed and related to the position you are interviewing for whenever possible 

K – Know the directions to the building (drive a practice run if you must) 

L – Legs should not be crossed; maintain open/receptive body language 

M – Mail them a thank you letter afterwards. Make this letter short, professional, and to the point. Thank them for their time and that you look forward to the opportunity to become part of their organization 

N – NEVER LIE! Answer all questions truthfully and frankly, but don’t “over answer” either 

O – Opportunity is the focus…not money. Be prepared to discuss the opportunity and how you can make a positive impact in the company. Never focus on how much money you can make or ask about financial compensation during the interview 

P – Professional attire is a must – even if you know the environment is casual, the interview is formal 

Q – Quality of work and a strong understanding of the core skills you are interviewing for are quintessentially important. 

R – Research the company and have questions prepared about it 

S – Sit upright, look alert and interested at all times 

T – Take a portfolio to take notes in (blue or black ink only) 

U – Update your resume and have 3 references before you go on the interview 

V – Vacation days should not be discussed but the value you bring to the company is a great focal point 

W – Wear a watch; even if it is broken, it will give you the illusion of being organized and prompt 

X –Xerox multiple copies of your resume in case you meet with more interviewers than you had expected 

Y – Yes or no answers to questions are not good enough; providing a short explanation of your answers proves your knowledge and experience 

Z – Zero in on what benefits you bring to the company 

Difference between CreateProcess and ShellExecute API Calls

Difference between CreateProcess and ShellExecute API Calls

CreateProcess and ShellExecute API Calls are very useful and closely related. In this article, I have tried to make clear the difference between CreateProcess and ShellExecute API Calls. You should know where and why to use CreateProcess and ShellExecute API Calls in your application. So here are some points of difference between CreateProcess and ShellExecute API Calls.

1. CreateProcess() is more oriented on low level and ShellExecute() on the high user level:

For example using of CreateProcess with correct parameters you can start the program which has the path larger as MAX_PATH. It has 32,768 characters restriction. You can also use CreateProcess to start program (if you have enough permissions) on another windows desktop like on the Logon Screen.

Another example: You can use ShellExecute to start Control Panel or open any program which existed on the computer for editing of JPG file for example. So you work with ShellExecute close to the corresponding actions in the Windows Explorer.

2. ShellExecute() is more flexible than CreateProcess(): An extension of my first point

ShellExecute() is a shell around the OS and defaults to the OS to run programs, which gives it a lot more flexibility than CreateProcess(), which engages the program directly, which is why you can't run, say, HTML files, or PDF files, etc., with CreateProcess(), but which can be run with ShellExecute().

ShellExecute() is a wrapper to the process of:

1. Determining the type of file by searching the Windows Registry.

2. Enumerating the allowed shell commands (verbs).

3. Retrieving the command line for the specified verb.

4. Constructing the command-line switches.

5. Calling CreateProcess() to start the process pointed to by the retrieved command line.

3. Handle Information

CreateProcess returns the handle and id for the started process and it's main thread in the PROCESS_INFORMATION structure. By using these handles, you can shut down the process whenever required but no handle is returned by ShellExecute().

Suggestion: If you just want to launch a file in a browser or notepad etc., ShellExecute() is probably what you want. However, if you know the exact .exe name you want to launch, using CreateProcess() gives you much more control.

Note: Do not use WinExec() as it is a deprecated function from the 16-bit days.

How to use CreateProcess API Call to create and execute a new process in Delphi XE4?

How to use CreateProcess API Call to create and execute a new process in Delphi XE4?

Executing a program or process in Win32 means loading a process and its child thread(s) in memory. CreateProcess is used to create and run the process in Win32. We will see how to use CreateProcess in Delphi XE4 to execute an exe? For backward compatibility, the Win16 calls for executing programs, WinExec and ShellExecute are still supported in the Windows API, and still work. But for 32-bit programs, they're considered obsolete.

The following code utilizes the CreateProcess API call, and will execute any program, DOS or Windows.

procedure ExecuteNewProcess(ProgramName : String; Wait: Boolean);
var
  StartInfo : TStartupInfo;
  ProcInfo : TProcessInformation;
  CreateOK : Boolean;
begin 
  FillChar(StartInfo,SizeOf(TStartupInfo),#0);
  FillChar(ProcInfo,SizeOf(TProcessInformation),#0);
  StartInfo.cb := SizeOf(TStartupInfo);
  
  CreateOK := CreateProcess(nil, PChar(ProgramName), nil, nil,False,
              CREATE_NEW_PROCESS_GROUP+NORMAL_PRIORITY_CLASS,
              nil, nil, StartInfo, ProcInfo);

  try
    if CreateOK then //Check if the process is created successfully
    begin
      if Wait then WaitForSingleObject(ProcInfo.hProcess, INFINITE); //Load children processes
    end
    else
    begin
      ShowMessage('Unable to run '+ProgramName);
    end;
  finally
    CloseHandle(ProcInfo.hProcess);
    CloseHandle(ProcInfo.hThread);
  end;
end;

In above code, I will pass an executable file to ExecuteNewProcess method lets say abc.exe.

Relation between Threads and Processes

Here it is very important to mention the relation between threads and processes. Threads are children of processes; while processes, on the other hand, are inert system entities that essentially do absolutely nothing but define a space in memory for threads to run - threads are the execution portion of a process and a process can have many threads attached to it. So, we can say, processes are merely memory spaces for threads.