Rob’s Technology Corner

See you at CodeRage

2011-09-23T08:17:00.000-06:00

I have never seen so many Delphi Events as we are seeing right now.

There is definitely a buzz regarding the new Delphi XE2

DelphiLive in San Jose has completed and it was a great event.

Half the Delphi World Tour dates have past, with a several more to go.
In Utah the Delphi World Tour represented one of the largest Delphi Event in Years.

Next Up is CodeRage Oct 17-21, 2011. It a FREE, virtual conference. For those who are confused about the idea of a virtual conference.... think of of it as 50 back to back webinars in 5 Days.

My team goes to training room with loads of junk food. Where we discuss the sessions as they occur. It really for good team building.

I will be sharing 4 sessions at CodeRage this year.

Learning Magic Tricks: The Beginners Guide to RTTI

Learn what RTTI is and how to use it. This session is designed for those that have heard of RTTI, but don't know where to start.

Practical Magic: Why would I use Delphi RTTI?

Attendees are shown several practical examples of how the RTTI in Delphi works.

Magic Unleashed: A Deep Dive into the Delphi RTTI

In this session, we pull back the covers and explore the internals of how RTTI.pas and TypInfo.pas work inside of Delphi exposing all of the RTTI options you have to use in your applications.

Exploring the Delphi Debugger

This session explores how to use the Delphi Debugger to find those difficult to find problems. We explore the little known features of the debugger that can make your life easier when real problems arise.

All of the RTTI sessions are back to back, allowing for Q/A after each. With three sessions I will be able to provide more information than I have ever been able to do before.

XE2 and Registration Headaches.

2011-09-06T15:36:00.000-06:00

Today I hit the registration limit on XE2.

I installed it on the following machines.

Laptop (Primary for DelphiLive Presentation)
Laptop (Backup for DelphiLive Presentation)
Desktop (Home)
MacMini, Windows VM
Desktop (Work)

Registered in in that order. I ran in to the registration Limit with #5. I am the only person who uses these machines.

So I think no big deal, I will request a registration limit increase. I requested the increase and walked away from my machine for meeting. Thinking I can wait 14 days to register no big deal.

Then I did the following.

1. File|New VCL Application

2. Ctrl-F9

Then the following dialog appears.

I have never been a fan of activation, but I have not been against it... Until Now!

Now that I can see that the 14 day grace does not just cripple the application on start-up, it annoys the developer and reduces their productivity.

The good news is that support did respond and the activation limit has been increased. But this is just a headache that paying customers should not have to deal with.

New Mac and Rad Studio XE2

2011-08-25T22:41:00.001-06:00

Note: I was given permission to blog about the Rad Studio XE2 Beta.

Today my first Mac OSX computer arrived at my home. I have only used a Mac when working
on Sound and Lights at local theatre. I have spent about 10 hours total time working on a Mac in the last 10 years. So I would guess this as close to a new user experience as one my expect.

The primary reason I bought the Mac is because Rad Studio XE2 supports writing applications for this platform. I like to make sure I stay on top of the various Delphi technologies so I had to buy one.

I opened the box and hooked up the various cables. Turned it on and I saw a little diagram asking me to turn on my touch pad or mouse. Well I turned on the touch pad and nothing happened. After trying various combinations I gave up and called support. After having to power of the Mac twice we were able to get the wireless keyboard and mouse to work. Things were not going well, and I was a bit worried I had made a mistake but things turned around.

I had installed the latest Rad Studio XE2 Beta version on my home computer, which is a Windows 7 machine.
Then I performed the following steps:
1. File|New Firemonkey HD Application.
2. I then right Clicked on Target platform and added OSx

I knew I had to install something on the Mac but I did not know where it was or how to do it.
I opened the Help file and found it had a Huge amount of information that pointed me in the right direction.
From the little I did read I was very very pleased with the depth of coverage.

3. I Installed the Platform Assistant on the Mac according to the instructions.
4. I launched the platform assistant clicking on the "paserver.command" in
"Developer" section of finder.

5. Then in back in Delphi, I right clicked on the "OS X" Target Platform and selected "Assign Remote Profile"
6. On the "Select Remote Profile for 'OS X' Platform" dialog I pressed "Add..."
7. I walked through the Wizard and Added Information about my Mac.

8. Then finally I selected the new profile that was created.
9. I then pressed the run button.

The application appeared on the Mac as expected.

I must say the out of the box experience with Delphi and the Mac looks very polished, it was very easy to setup. I spent more time trying to get the wireless mouse and keyboard to work than getting Rad Studio configured and my first App running.

Now that I have a basic app running it's time to really explore how FireMonkey integrates will both Windows and OS X.

For more information check out the Rad Studio XE World Tour or the Delphi Live conference.

THtmlWriter - First Look

2011-06-15T00:15:00.000-06:00

I wanted my build process to automatically generate a web page with what was changed in the given build. Basically I had to query our Internal Bug Tracking system and produce a web page. Allowing me to take a

snapshot of bug tracking system as it looked liked when the build was produced.

This was going to be a simple console application that our build could run.

So I decided to try THtmlWriter written by Nick Hodges.

I spent more time reviewing the code of THtmlWriter than I did actually using it.

It was very easy to use, and will most likely use it in future

If you need to produce HTML from Delphi application it's worth looking at this.

So here is my +1 Vote for THtmlWriter

Application -vs- Component Developer

2011-06-07T12:34:00.000-06:00

During Interviews I have heard the following from candidates.
"I am Application developer, I use components, I don't build them."

I typically have thought well I have found another "point and click" developer who is not familiar with OOP. Since I have been at my component no candidate who has said this has been hired.

Recently I ran into an exception (outside of an Interview) a Delphi Developer who was very familiar with OOP but had still not built a component. I realized that there an artificial barrier into component development, that many might see. In a future blog postI will confront this artificial barrier head on and show how easy it is to do component development. This post is show some of the arguments of why we would want to do component development as an application developer.

In 2007 we converted our application from BDE to DBX. We had written an application that converted all TQuery components to TDbxQuery components.

The process of conversion to the 3 component model of DBX (TSqlQuery -> TProvider -> TClientDataset) was going to be error prone. It was also going to take an insane amount of time that we were not willing to spend.

So we spent a few days creating a component that looked like and behaved like TQuery but internally used the 3 Component DBX model. It was similar to TSimpleDateset but had properties and functions that matched existing TQuery functionality that we used. This allowed for a search and replace of instances of TQuery with TdbxQuery. This allowed us to complete this conversion in less time that if we had just used the built in components. Since we maintained the component we were able to expose any functionality of the 3 components model that we needed.

During this process we realized we had hundreds of TDBGrid components. So we decided to help our application for the long term. We replaced TDBGrid with TDwsGrid. Initially the code looked something like this. It basically offered nothing over TDbGrid.

TDwsGrid = class(TCustomDBGrid)
   published
    property Align;
    property Anchors;
    property BiDiMode;
    property BorderStyle;
    property Color;
    property Columns stored False; 
    property Constraints;
    property Ctl3D;
    property DataSource;
    property DefaultDrawing;
    property DragCursor;
    property DragKind;
    property DragMode;
    property Enabled;
    property FixedColor;
    property Font;
    property ImeMode;
    property ImeName;
    property Options;
    property ParentBiDiMode;
    property ParentColor;
    property ParentCtl3D;
    property ParentFont;
    property ParentShowHint;
    property PopupMenu;
    property ReadOnly;
    property ShowHint;
    property TabOrder;
    property TabStop;
    property TitleFont;
    property Visible;
    property OnCellClick;
    property OnColEnter;
    property OnColExit;
    property OnColumnMoved;
    property OnDrawColumnCell;
    property OnDblClick;
    property OnDragDrop;
    property OnDragOver;
    property OnEditButtonClick;
    property OnEndDock;
    property OnEndDrag;
    property OnEnter;
    property OnExit;
    property OnKeyDown;
    property OnKeyPress;
    property OnKeyUp;
    property OnMouseActivate;
    property OnMouseDown;
    property OnMouseEnter;
    property OnMouseLeave;
    property OnMouseMove;
    property OnMouseUp;
    property OnMouseWheel;
    property OnMouseWheelDown;
    property OnMouseWheelUp;
    property OnStartDock;
    property OnStartDrag;
    property OnTitleClick;
  end;

The other day I had a look at this component, it now does the following.

Sorts the Grid based on Click of column Title
Persists Column positions and sizing to a configuration file.
Ability to Export to Excel.

It's not a huge amount functionality but it allowed us to add this to many screens without how having to place this code to do this in every place we used TDbGrid.

When explaining this to application only developer one might expect a response of. "Well why not buy a 3rd party control that does that?" My answer "We did just that, when we had the budget we purchased a TMS Subscription and now use TDBAdvGrid in many places."

But the experience previously learned still applied to 3rd party component packages. We now are in the processed of creating, our new component which now looks like this:

TdwsAdvDbGrid = class(TAdvDBGrid)
end;

Allowing us to add additional functionality to TAdvDBGrid if we need it. Granted for now we don't need to add anything. But the lesson learned from the previous experience has shown the value.

This does not just apply to additional functionality, it also applies to common custom settings.
Say for example every time you use a TEdit you need to change the Font to comply with a standard
you have set. Instead of doing the tedious mistake ridden work of doing this. Instead create a TMyEdit then use that instead of TEdit.

interface

uses
  SysUtils, Classes, Controls, StdCtrls;

type
  TMyEdit = class(TEdit)
  public
    constructor Create(AOwner : TComponent); override;
  end;

procedure Register;

implementation
{ TMyEdit }

constructor TMyEdit.Create(AOwner: TComponent);
begin
  inherited;
  Font.Name := 'My Crazy Font';
end;

So basically a developer should be able to do both, application and component development. Taking the time to learn component development will only help you in your your abilities to create great applications.

Runtime/Designtime what? Delphi Packages

2011-06-02T19:34:00.004-06:00

To most Delphi developers a package is typically where you would place components so that you can drop them on your forms.

So one might assume that a 3rd Party Component developer would know how packages work. Well over the years I have seen several of these developers make basic mistakes when it comes to Delphi packages.

The application I work on is built with runtime packages. We currently have to deploy 208 packages.
Management of Packages and having the built correctly is paramount for us. Not all packages involve components, but the most common mistakes happen at that level.

This blog post is my attempt to help developers understand one area of packages, that I typically see mistakes.

A package is just a collection of units that are complied together into a BPL.

Here is the package sources for brand new package with a single unit.

package Package2;             

{$R *.res}
{$ALIGN 8}
{$ASSERTIONS ON}
{$BOOLEVAL OFF}
{$DEBUGINFO ON}
{$EXTENDEDSYNTAX ON}
{$IMPORTEDDATA ON}
{$IOCHECKS ON}
{$LOCALSYMBOLS ON}
{$LONGSTRINGS ON}
{$OPENSTRINGS ON}
{$OPTIMIZATION ON}
{$OVERFLOWCHECKS OFF}
{$RANGECHECKS OFF}
{$REFERENCEINFO ON}
{$SAFEDIVIDE OFF}
{$STACKFRAMES OFF}
{$TYPEDADDRESS OFF}
{$VARSTRINGCHECKS ON}
{$WRITEABLECONST OFF}
{$MINENUMSIZE 1}
{$IMAGEBASE $400000}
{$IMPLICITBUILD ON}

requires
  rtl;

contains
  Unit13 in 'Unit13.pas';

end.

There are two key sections requires and contains.

Contains is the list of units that your package contains. Requires is the list of other packages your package needs to compile. For example say you have a pkgBaseBall.bpl that contains a unit called baseball.pas.
Then you create a new packages called pkgSports.bpl that contains a unit called sports.pas which listed baseball.pas in it's uses clause. You will need to add pkgBaseBall to the requires clause the package named pkgSports.bpl

Key Files involved in package development.

*.DPROJ - XML File in MSBUILD format that contains project options and files.
*.DPK - Main source code of the package. (It's the code listed above)
*.BPL - Compiled Binary
*.DCP - Delphi Compiled Package, contains information about he interface section of the contained units.

Package Types
There are 3 basic types of Packages.

Designtime only
Runtime only
Designtime and runtime

Runtime Packages

When creating a Delphi you have the option to build with runtime packages. This option is found in the project options.

If you build with packages you must distribute the packages (.BPL files) your application uses.

Most Delphi application that I have seen are build without runtime packages. Typically these developers tend to not realize the impact bad package design can cause on application that uses runtime packages.

When building with runtime packages the list of package you must distribute is semi-colon delimited list next to the check box for Build with run time packages in the project options. The only files you need to distribute for applications build with runtime packages is the BPLs. The other key package files do not need to be distributed.

Runtime packages should never contain or require designtime code.

Designtime Packages

Designtime packages are where you place your design time code. This includes

Property Editors
Component Editors
Open Tool Experts
References to other packages that are design time.
Component Registration "i.e. the Register method."

Designtime packages should never contain runtime code.

Designtime and Runtime

This is the lazy developer package. I don't want to create and maintain two packages, so I will just use one. This seems easy at first, but if not done carefully it leads to the most common mistake I run into. Then write some code that requires a designtime only package. This in effect makes your package designtime only regardless of your package type selection. It's easy to do any property or component editor will require DesignIDE which is design time package that you can't distribute.

The Rules
The summary version of common mistakes.

"Runtime" Packages should never contain Design time Code
"Designtime" Packages should never contain Runtime Code.
"Designtime and Runtime" Packages should never Require "Designtime" Packages.
"Runtime" Packages should never Require "Designtime" Packages.
Avoid "Runtime" Packages that require "Designtime and Runtime" Packages
Avoid the use of "Designtime and Runtime" Packages.

Why do I care?

If an application builds with runtime packages, and someone screws this up you will find that application requiring deployment of design time packages to work. If you do deploy the runtime package, you may run into a a runtime error "Application is not licensed to use this feature" This is because your using files that you should not be distributing.

Find Text in Delphi - Evolution of a Feature

2011-05-31T08:29:00.002-06:00

Every application goes through evolution, where a feature is completely rewritten to be better.

Understanding how a given Feature is used is important before undertaking the rewrite, to know how your going to impact your user base.

The case I am going to point out today is the difference between the Delphi 2007 and XE find text mechanism. The XE version changes are frustrating at best. Do see what I am talking about
do the following in both IDE's.

File| New VCL Application
File| New Form (So you have two blank forms open)
Navigate to the code of one of the forms
Ctrl-Home (Move to top of unit)
Ctrl-F (Delphi 2007 Dialog - Delphi XE it's at the bottom)
Enter "Form" as the search word
Press Enter (First Match is found in uses)
Press F3 (Second Match Found)
Press Ctrl-Home (Go back to top of document)
Steps change from here on out....
Delphi 2007

Press F3 (Finds First Match Again)
Change to second unit's source code
Ctrl-Home
Press F3 (Finds First Match in 2nd Unit)

Delphi XE

Press F3 (Nothing happens, Argh the search window says "Form" nothing is found. QC: 80696)
Ctrl-F ( Text changes to "Unit" QC: 92388)
Retype : "Form"
Press Enter
Change to second unit's source code
Ctrl-Home
Press F3 (Nothing happens , Argh. Note: The search window at bottom is not visible)
Ctrl-F ( Text shows "Unit" )
Retype : "Form"
Press Enter (Finds First Match in 2nd Unit)

Update: If I restart Delphi and the Press F3 and nothing happens step works. Something is causing it to break just don't know what it is.

It's also bad if you search on a term don't find it and want to use the Find in Files functionality. But, I think I made my point with the steps above.

I have heard the arguments about the new find method being better. Personally I could care less if it's a dialog or at the bottom of the form. The new method is even entered it as bug in QC: 80695

What I do care about, is that the functionality works for me and not against me.

So as evolution occurs in your application, take a moment to realize the use case scenario of the existing functionality. That way you impact your users for the better and not for the worse.

The Joel Test The Evolution of a Team.

2011-05-14T19:21:00.001-06:00

Every place I have worked has had a different staff hiring and/or contractor selection process. When I started working with my current employer the process was simple. Come in for one interview, after reviewing the resumes, and a brief conversation with each candidate a decision was made.

A bit later I became the one in charge of doing the hiring. I followed the same basic model for awhile, then I was bitten. I had a few bad apples. I then read Smart and Gets Things Done: Joel Spolsky's Concise Guide to Finding the Best Technical Talent, which talks about the Joel Test so I took the test from my point of view of my team.

Do you use Source Control? (YES)
Can you make a Build in one Step? (NO)
Do you make Daily Builds? (NO)
Do you have a Bug Database? (YES)
Do you fix bugs before writing new Code? (NO)
Do you have an up-to-date schedule? (NO)
Do you have a spec? (NO)
Do Programmers have quiet working conditions? (NO)
Do you have the best tools money can Buy? (YES)
Do you have testers? (YES)
Do new candidates write code during their Interview? (NO)
Do you do hallway usability testings? (NO)

So our test was a 4 out of 12. I wish I remember how long ago I did that, but things have changed since then and even our YES answers have became better.

Do you use Source Control? (YES)
Can you make a Build in one Step? (YES)
Do you make Daily Builds? (YES) -
Do you have a Bug Database? (YES)
Do you fix bugs before writing new Code? (YES)
Do you have an up-to-date schedule? (YES)
Do you have a spec? (YES)
Do Programmers have quiet working conditions? (NO)
Do you have the best tools money can Buy? (YES)
Do you have testers? (YES)
Do new candidates write code during their Interview? (YES)
Do you do hallway usability testings? (YES)

New Score 11 of 12, not perfect but much better.

The quality and the output of our team has increased dramatically in the past few years. Some of that is attributable to doing the things on that list.

Do you use Source Control?
When I started we were using Visual Source Safe, we have improved in this area by switching to Subversion.
We never used branching before, now it's common to branch. We have built a one button deploy of our software using FinalBuilder. When we select the option to deploy to production which automatically tags the revision number that was used to build the software. We are currently investigating Mercurial or GIT but we have not decided on which and need to find a logical break to switch.

Can you make a Build in one Step? Do you make Daily Builds?
We purchased FinalBuilder several years ago which helped made this a reality. Our first build script was triggered as needed. It was run on an old desktop machine. We then step it up on a timer and it ran every hour, then our speed of our build decreased and we had to run it every two hours.

Our initial design was that we built and then deployed in the same script. That was a mistake, as we had to rebuild the application every time we change where we wanted to deploy For example Development, Test, QA, Production. So the scripts were changed to build and the deploy to a staging directory. Then we could deploy to any of the 4 environments. This insured that the exact same binary that was tested was moved into Production.

We then invested in FinalBuilder Server which allowed us to start the build every time someone committed.
This improved our turn around time for our testing team, but the builds where still quite long. So we took some time to analyze what was slow, fixed some problem areas of our scripts and invested in better hardware
for the build. Our builds now take 10 minutes to complete, instead of the 2 hours.

Do you have a Bug Database?
Our first bug database when I arrived was a single table Delphi application that stored a limited single description of a problem, who it was assigned to and if it had been resolved. Since then we adopted
an Bug Tracking database that another team had built. It's web based and has nearly everything we
need. We have used the TortoiseSVN bugtraq properties to Integrate our Bug database with SVN.
We also track new development in our Bug Tracking Database. This allows to to tie development
requests regardless of type to the actual code that implemented them.

Do you fix bugs before writing new Code?
We don't fix all of the bugs in the application before we write new code. However, if we want to write new code in a specific area, we find the existing bugs in that area and fix them before heading off.

Do you have an up-to-date schedule?
We try to be agile in our process. We hold daily stand-ups, and do iterations. Our planning of what occurs in each iteration is working as expected. As we have refined our process our ability to know how long
something is going to take has improved dramatically. We still are not accurate, 100% of the time but things
balance out more often that not.

Do you have a spec?
We did not have specifications for the longest time. But last year we completed a several month project to develop business rules for all areas or software covered. This is useful as the business desires to change an area they update the existing documentation. It really helps to find the dependencies and test all downstream code. It also gives direction on what is needed to the software developer. We don't spend time with UI specification, unless it's critical. Business rules is usually more than enough here.

Do Programmers have quiet working conditions?
This actually has become worse since I started, our cubical sizes have shrunk. I have no control on cubical sizes, so I have focused on what I can control. Many of the developers now where headphones to attempt to get quiet working conditions. I personally own two pairs of Audio-Technica ATHM40FS Precision Studio Headphones, one for work and the other for home. They use a 1/4" Jack so if your trying to use your 1/8" Jack you will need an adapter. It's my only way to find a quiet working environment, but they do work, I can't hear the phone ring when they are on :-)

Do you have the best tools money can Buy?
When I arrived we had Delphi 3 and Delphi 7 was was the latest version. They quickly upgraded, so I have always felt like I had the best tools. But since that time we have turned to Maintenance for all of favorite tools, so we have access to the latest tools. It also make budgeting easier.

Do you have testers?
When I first arrived we had a loose group of super users who tested as part of there responsibility. We still have these testers, but we also now have a formal team of people dedicated to the QA of the product. This really took some time to change, but the benefits are huge.

Do new candidates write code during their Interview?
This is what really was the genesis of this blog post. Although team fit/personality is part of the equation it's
not nearly as important as being able to code. If your hiring a developer on just an Interview your bound to find "Bad Apples"

Recently we hired two Contractors, we had over 20 applications and they all looked like qualified Delphi developers. We sent out a written interview. With some SQL questions, we also had two simple coding questions. They both could have been answered with little work in less than 8 lines of code. I was amazed by the number or 30+ lines of code answers.

This quickly reduced the pool of candidates below 10. We then did some actual Interviews reducing the pool of candidate even more. Then we sent them off on a 3 hour coding assignment, with full access to the Internet.

Some people familiar with the process call it brutal, but I have yet to select someone who has poor coding skills but is great in an interview again.

Do you do hallway usability testings?
We could do more to promote this, but it's common for a developer to pull someone at random to come look at something to see how they react.

In summary

This took quite a bit of time to implement, it was not an over night process. But each individual step along the path has improved our team. It's something I would encourage each development team to consider.

Happy 16th Birthday - Delphi

2011-02-14T07:20:00.000-07:00

Happy 16th Birthday - Delphi!

Thank you again, to all those involved with Delphi.

Last month I was able to go to San Francisco to talk as a Rad Studio customer to talk to Embarcadero sales team. Where I was able to meet most of the executive team and hear some directions and plans. From the small little bits I learned there I can insure you that the direction of Delphi is in good hands. Some of this has been hinted at during Jim's Podcast's with Allen Bauer, episodes 44, and 45.

Last year I posted a Happy Birthday Delphi message. At the end of that message I asked for Delphi to find it's self back into the entry level market. I please with the directions that have been taken. The Delphi Starter Edition has been released with a price point that opens the entry level market again. I have also learned that the academic pricing is available for the product that is 90% of the list of the original product. For a student this means that the professional edition can be purchased for around $100 USD which is the same price as the starter edition, and for labs I think it can be even cheaper.

Windows 64Bit OS - Directory Layout

2011-02-10T10:23:00.001-07:00

Short and sweet, as I had someone ask me about this today...

The \windows\system32\ directory on 64 bit version of Windows does not contain 32 bit files it contains 64 bit files. The 32 bit files are stored in \windows\SysWOW64

WOW stands for "Windows on Windows"

Go figure, the 32 bit files are in a directory with 64 in it, and the 64 bit files are in a directory with 32 in it.

According to the road map the next version of Delphi should be able to produce 64bit applications so it's important to know this detail.

Job Openings @ State of Utah

2011-01-07T22:30:00.000-07:00

I work for the Department of Technology Services for the State of Utah.
I am assigned to work at the Department of Workforce Services.

We recently have opened up a few new State Employee based position, which is really a rare thing.

All Jobs at the State of Utah can be located here: https://statejobs.utah.gov/
These are all Full-Time positions with work being performed in Salt Lake City, Utah.

Benefits are good, we work Monday-Thursday for ten hours a day, so you always have
a long weekend. We have a good working environment. We also have excellent Benefits
which include (not a complete list) medical, dental, and life insurance. 1.5% employer contribution into 401(k). Annual, Sick and Holiday Leave. Finally last but not least a Pension with 4 years to become vested.

On my team I have two openings for Delphi Developers. We currently have 10 People on my team, we practice agile techniques development.

My team currently uses the following technologies.

Languages:

Rad Studio XE Enterprise (under maintenance so we always have the latest version)

Delphi Win32 2007, XE (Primary Development Tool)
Delphi Prism XE (Secondary Development Tool)
C++ Builder 2007 & XE (Limited)

Visual Studio C++ Express (Limited)
C# (Limited) typically using Sharp Develop

Databases

Oracle 10g (Project underway to move to 11g)
Sybase (Limited)

Tools (list not complete)

Subversion
Final Builder
Test Complete
Toad

Libraries (list not complete)

JCL
Envision Imaging Library
TMS Components
Rave Reports
Gnostice eDocEngine
Turbopower Abbrevia
Turbopower LockBox

Delphi Job details listed here:
https://statejobs.utah.gov/JobAnnouncement.jsp?rid=22780

On our web team we also have two openings for C# Developers details listed here:
https://statejobs.utah.gov/JobAnnouncement.jsp?rid=22817

We also have a Versta Developer opening which is a framework based on Java.
https://statejobs.utah.gov/JobAnnouncement.jsp?rid=22806

If someone wants to be considered for multiple positions they need to apply for each
as they are under different hiring managers.

No Commercial Version of RAVE for Delphi XE

2010-10-12T11:25:00.000-06:00

Where I work our product is very tied to Nevrona's Rave Reports. We are based around the NDR file format and concept. Since the release of XE our emails to Nevrona and being ignored we still don't have an XE version of RAVE Reports.

XE is a compelling upgrade for us and as such we have decided to try to upgrade RAVE to XE. We do have the commercial 8.0 release.

I don't know about Embarcadero's agreement is with Nevrona but I don't think it's in the best interest of either party to keep bundling RAVE to with Embarcadero. From Embarcadero's point of view they are shipping a product that points to a company that all but appears dead. From Nevrona's Point of view they may be able make revenue on a product from those that need to upgrade Delphi versions. Maybe returning a revenue stream that they have lost because most users just use the free version. I know they can't be making much money now.

I actually would like to see RAVE become open source. I know my team would be at the very least committing changes to keep it updated to the latest compilers.

As for our long term roadmap, I don't have a clue.... Research begins now... Looking for Reporting solution that can temporary file that can then be printed, exported to Excel, specified pages of the report can be converted to an image. (We use TIFF but I can convert from about any format)

CodeRage - Audio/Recording Equipment

2010-09-12T11:44:00.001-06:00

I was just accepted to do two CodeRage Sessions, I am excited about both of them.

Building Robust Applications with Customized Exception Management
Continuous Integration with DUnit and FinalBuilder

I hope everyone gets a chance to attend some of the sessions, the exact dates and times of my sessions are not known yet. The conference is scheduled for October 4-8, 2010.

What I used in the past and will still
use to monitor broadcast audio

Right after I graduated from high school, I attended university as a theater major. That lasted about 2 years before dropping out to become a full time Delphi programmer. :-) But my love for Theater is still in my life. I volunteer at our local theater, building sets, running shows, and many other things. As such, I developed an appreciation for quality sound.

One of the things I observed in my past recordings was my audio quality was not what I wanted it to be. I also don't have a huge budget to turn my office office into a studio, but I did make some investments to try to improve the quality of the sound. About $280 later this this is what i have:

The New setup

A new microphone

A new mixer and headphones

USB Audio Interface

Behringer UCA202 U-Control Audio Interface

And the cables needed to hook it all up.

I have now done some test recordings, and I really pleased with the quality of my voice. If I were only doing an audio podcast I would have a near perfect setup. But with a good microphone comes some problems, related to the acoustics of the room, I now can hear the keyboard, mouse, the squeaky chair, the fan on the computer, and a slight echo. I also can hear the kids if they are talking in the room next door. To get the audio in my office where I would want it would be another $400-$700 not something I am going to spend any time soon.

So some tricks I have learned: A laptop keyboard is much quieter than my desktop keyboard so I most likely will be presenting on it instead of my desktop. Strategic placement of hung blankets helps with the Echo of room which reduces other noises. I suspect some WD-40 on the chair will help with the squeak or I will just switch chairs. If I am recording noise reduction will remove most of the noise from the computer fan. This but it won't help with the live presentations, so I might pull out the longer cables I have. to isolate the computer, as I still need it even if I am not typing 100% of the time on it.

Overall I hope that future live and recorded sessions of mine will have better audio for everyone. Even if I am the only one that may notice the difference in the end .

Rad Studio XE - DelphiLive

2010-08-31T13:29:00.000-06:00

At DelphiLive last week it was fairly obvious that Embarcadero was close to shipping RAD Studio. When there I took a few photos, and Jim wanted to play with the Camera so he took more :-) I have recordings of the keynote session that I will be posting in the next day or two on the VDUG site.

Well RAD Studio XE was released yesterday, and I am really impressed as SA/Maint Customer I received the keys and the download the same day. I was able to get the full product installed today. In past releases I have had to wait a few weeks to get the product, so this is very welcome change.

I had an Windows XP Machine and I bit shocked by the menu bloat, and I did not even install InterBase or Installaware. But it does highlight some of the new editions the the RAD Studio Line. For Delphi and C++ Developers they get to look forward to Automated QA, and CodeSite. For Delphi, C++ Builder, and Delphi Prism developers they get Subversion Integration, FinalBuilder. Rave Reports is still the product, since we depend on it I am happy as it appears that Nevrona is all but a dead company. Delphi Prism now integrates into both Visual Studio 2010 but also MonoDevelop. There is even an install for Delphi Prism to install with MonoDevelop on a MAC. To round out the Menu RadPHP (Formerly Delphi for PHP) is now included in the RAD Studio XE product line.

There are a few other new items bundled with RAD Studio XE that don't create menu items (Thank you for not doing that!)

Beyond Compare
IP*Works components (Indy is still there!)
RemObjects Oxfuscator

And I would not be surprised if I missed something else that is bundled. Of course my next questions and potential blog posts are what is under the covers.

DelphiLive - I am here!

2010-08-23T20:26:00.000-06:00

I am now at DelphiLive, I ran into the guys at RemObjects. Today waiting for the conference to get underway we took a little trip to Cupertino to visit Apple and had lunch. Marc nearly sold me on an iPad his with 3G support was used quite a bit as we navigated the streets. One of the things we talked about was RemObjects TV, which really looks good. BTW I found out that some of the VDUG videos don't work on iPad and that Jim re-encodes the Camtasia results to make it work on iPad. They guys at RemObjects are all carrying Flip Ultra HD Video Cameras, and I suspect we will get all sorts of good material from it. I am carrying a Kodak Zi8 and Digtal Rebel T1i so I have a couple of options to gather and share what is going on here.

Looking forward to the keynote tomorrow!

Personal Outlook #2

2010-06-03T12:46:00.002-06:00

Virtual Meetings
I enjoy attending virtual events, it's a good way to learn and share information. It's one of the reason's I started the Virtual Delphi Users Group. I am always on the watch for good virtual events. I have multiple computers every place I code. With a virtual event I typically start it on a secondary computer and stay coding. If I hear something interesting I look at the second machine to see the details. On occasion something really good is covered and I never get back to coding.

For the next VDUG meeting we had advertised covering Delphi Prism 2011. I just found this event "Extreme Cross-platform .NET with Delphi 2011"" presented by David I. Which is the week before the VDUG Meeting, and was going to cover nearly the same material. Not wanting to just show the same thing, I am going to change the topic a bit. So, I think everyone should attend the event with David I.

As for the VDUG Meeting, I am now working on refining a deeper dive into the Delphi Prism Language Features. With some of the things we have learned trying to keep some of our code cross-compiling with Delphi Win32. When I get the material prepared I will announce the new meeting on the VDUG Site.

Another virtual event I found today that looks interesting is a 3 hour Virtual Conference with Kent Beck on Continuous Deployment. Since I have enjoyed many of his books. Most of the time virtual conferences by the media companies are so product specific that if you don't use the product it's a waste of time. But this looks interesting and I think I can apply the topic to our situation. Specifically we currently use FinalBuilder Server to monitor our SVN repository for changes, which when detected they are automatically built and deployed to our test environment.

Stackoverflow Code-Golf
On stackoverflow.com there is a tag called Code-Golf that contains challenges to the write the smallest program possible meeting the requirements of the challenge. I took note of this question and answered it in Delphi. It shows that you can do cryptic things in Delphi, just like you can in other languages. I think it's a good example of why you should use descriptive variable names and types. The answer was the ugliest code I have ever written.

Virtual Delphi Users Group

2010-04-24T00:48:00.001-06:00

On April 20th, 2010 SLCDUG conducted an experiment on a virtual meeting. The results were much better than expected. This concept worked! I have work to do to improve the overall experience. We had several minor problems, but overall we can improve.

One thing I realized needed to improve was it needed to have a central place were we could announce meetings and store recordings. The SLCDUG site is just a blogger account and would not support files of the size the recordings.

So I setup a new domain and website just for the "Virtual Delphi Users Group"

Now, I find myself personally using Delphi Feeds most of the time so I want the VDUG Feed listed there, if you want to see it then vote for my submission. (UPDATE: It's listed!)

The replay of the first meeting: Component Development / Tips & Tricks has been posted on the the new site.

If your interested in sponsoring this group in any way let me know: rlove at peakbiz dot com

Virtual Delphi Users Group Meeting

2010-04-14T08:58:00.000-06:00

I will be presenting at a Virtual Delphi Users Group Meeting Next Week.

Everyone is invited and it's free of charge.   It's not going to be a marketing show like a typical Webinar, it just plan free training on Delphi.

Date: Tuesday April 20, 2010
Time: 6:00 PM MDT (UTC - 6 hours)

Topics:
   Delphi Tips & Tricks - Phil Gilmore
   Delphi Component Development - Robert Love

Pre-Registration is required: https://www1.gotomeeting.com/register/512344336

I have more material on Component Development than time will allow, as such I will poll those attending the meeting to decide on the direction to take.

This will be the first of hopefully several, it really depends on participation levels, i.e. don't want to prepare and have nobody show up :-)

Personal Outlook #1

2010-04-06T11:46:00.000-06:00

Just Learned about AsmProfiler when reading this Stackoverflow Question initial take is that it looks promising. I am going to try it next time I need to profile something.
Recently purchased TMS VCL Subscription. I just sent our first contact with support was a feature request yesterday. Early this morning I was sent code implementing the feature as a patch. Talk about fast support!
I am going to bite the bullet and spend the additional money and use GotoWebinar for the first SLCDUG Virtual meeting now I just need to get a topic together, and the new virtual meeting format. The date of the meeting will be April 20th, watch the SLCDUG website for details.
Visual Studio 2010 launching April 12th, I wonder how long until we see Delphi Prism for VS 2010
Homage to Nick Hodges commonly post entries to his blog called Random Thoughts on the Passing Scene in a similar format :-)

Virtual User Group Options

2010-04-04T13:12:00.001-06:00

The SLCDUG (Salt Lake City Delphi Users Group) is going to do some of it's meetings on-line.

I started researching many options of what technlogy to use, with the following factors playing into my decision:

Cost, since we don't collect dues the cost needs to be small enough that I can personally handle it if there is not a sponsor willing to pick up the tab.
Options are available to make this more like a local users group meeting than pre-scripted webinar presentation.
We have attendance in the past year at anywhere from 4 people to 50 people. Because our virtual meetings will be available to everyone on the Internet, we need a solution that supports at least 100 people.

I was surprised to find that there is not a ton of un-biased reviews. For example the most compressive review of GoToWebinar was done by a Cisco employee the company that produces Webex. With that in mind I knew I could not depend on others research. So I setup multiple computers in my home all signed up for the trial offers of the following companies and this is what I found in my comparision.

GoToWebinar
Price: $99/Month
Max Attendees: 100 @ $99 * 500 @ $399 * 1000 @ $499
OS Supported: Windows, MAC
Trial Length: 30 Days
Pros:

Interface was easy to use.
Control windows are not broadcast
Ability to view only one application instead of the entire desktop.
Support for VOIP and Telephone conferencing for presenters and/or Attendees
May unmute either option quickly via software.
Up to 25 People could be unmuted.
Good registration and Tracking of who attended.
Was able to show a small video clip without slow down.
Ability to share or hide Attendees List
Easy to schedule future meetings
Ability to make someone else the presenter without reconnecting

Cons:

No support for Web Cams
No Support Linux
Can not be run from a virtual machine

WebEx
Price: Contact Sales (Scared here as 25 users is $49/Month but I have sent an email request)
Max Attendees: 500 (Meeting Center Product) 3000 (Event Center Product)
OS Supported: Windows, MAC, Solaris, Unix, Linux, 3G Enabled Smart phones (IPhone, Blackberry, Nokia, etc)
Trial Length: 14 Days (Meeting Center) unable to trial Event Center
Pros:

Control windows are not broadcast
Optional support to allow attendees to chat with each other.
Ability to Share or Hide Attendee List
Ability to make someone else the presenter without reconnecting
Easy way to schedule future meetings

Cons: (Based on Meeting Center)

No way to register for a meeting.
No way to see reports on who attended after meeting.
Interface seemed to get in the way more than I wanted.
Had Problems starting a 2nd Meeting after first trial meeting.
Users Joining meeting were prompted to join 14 day trial (Our attendees are not their customers!)

LiveMeeting
Price: $22.50/Month ($4.50 per user per month min 5 Users)
Initially this was confusing but figured it out. Each Organizer need a license, attendees don't so the minimum license count will work for our situation)
Max attendees: 250 (Can get up to 1250 if you pay $16 per User)

OS Supported: Windows, any Java supported OS (Java Version does not support VOIP)

Trial Length: 30 Days (It's all of Microsoft on-line services, not just LiveMeeting)
Pros:

Price is very good.
Ability to Show or Hide Attendee List
Ability to allow Users to Create own Personal Recording
Optional Pre Registration
Embarcadero Uses it for CodeRage so people are familiar with it.

Cons:

Organizers are required to use a Sign In Application, that reconfigures Outlook.
Most Difficult (As an Organizer) to get setup initially
Web Version does not support VOIP / Clients must Download Live Meeting to get VOIP
Only supports External Phone Conferencing Providers, not provided by Default.
If I allow all attendees to have MIC access, I can't control the Mute. They can unmute themselves at will. You can mute everyone but yourself but they can turn around and unmute immediately.

DimDim
Price: $75/Month (DimDim Webinar Version) (There is a Free version for 20 or less attendees)
Max Attendees: 1000
OS Supported: Windows, Mac, and Modern Browser that supports Flash.
Trial Length: 30 Days

Pros:

Optional Public Group Chat
Poor Support for Question and Answers, Private Chat was the only option.
Registration Support
Phone or VIOP Support
Price for smaller meetings
Cool count down timer and Registration Widget to embed on site later
Open API for setup of Meetings. (although: Lacked in Meeting API controls)
Will host Recordings
Shared Browsing Feature

Cons:

Speed of switching content views.
Only can share whole desktop. Annoying Red box around screen.
No built in Polling
Registration Required Field are not changable (I don't care about phone number but DimDim makes it required)
Several Support Forums, with no clear direction where to go. They were confusing at best.
Recording will not record everything, currently does not support white board or shared browsing

Common Problems regardless of option:

Unable to Broadcast PC Audio without setting up, Sound Mix and disabling your Mic or using a second PC/Mixer Board.

Right now I am leaning to LiveMeeting because of price, but my favorite is GotoWebinar, its features are far more robust and would go along way in making the session seem more like a local user group meeting.

I am interested in feedback on those that have experience in using these technologies or other options I did not review.

Update: Added DimDim to the list of products reviewed

Happy 15th Birthday Delphi - My Delphi Story

2010-02-14T01:00:00.004-07:00

On February 14, 1995 the first version of Delphi was released. Little did I know how much this would affect my life.

I had learned to program using Apple II Basic in grade school. In high school, I was able to enroll in the AP computer science program. At that time it was taught using Turbo Pascal 3.3. I don't really remember when I purchased my first compiler, but I do know that it was TP 5.5. During high school I started writing shareware programs using TP 5.5 for the VBBS System. I earned enough money to support my newly formed programming habit. I purchased many of the libraries offered by TurboPower.

I graduated from High School in 1992, I enrolled in college with a major in Theater :-) Little did I realize that little habit of mine was going to change the course of my life. While in college I started working as a tech support specialist for Prodigy after a short period I was promoted helping manage the LAN with both desktop and server support. We were running in an OS/2 environment and took my first look at C to help manage many of the things we needed to do. I was successful but I realized I did not like the language, as much as I did with Pascal. During this time, I was fairly active reader of the Compuserve Forums for both Borland and TurboPower allowing me to learn of a new product. I purchase Delphi the moment it came out, I also started attending the Salt Lake City Delphi users group. At one of the meetings I met, my soon to be future boss, who was looking for a programmer. The company was very small operating out of a home that was converted into an office. I did the programming for an application that manged the bookings for timeshare properties. It was also far enough away from my school that I had to drop out of college.

Wanting to continually improve my programming skills I attended Software and Development West in San Fransisco. There I found the Borland booth, and I ran into the Interbase marketing manager. I told him about the work we had done with the Interbase API to make things faster and avoid the BDE. I told him how we had developed UDFs for InterBase using Delphi. I remember him saying: I did not think you could do that, do you want to come speak about what you have done at our conference. A week or two later I contacted him and said yes to the offer to speak at the conference. I was going to be surprised, I was still a very green programmer and I had never had attended a Borland Conference before. I don't remember much about the conference materials. I do however remember the way I felt during the session I presented. I had written a couple of very large white papers on the subject, so I felt prepared. I also felt very young and scared. When it came time for the question and answers section of my sessions, I was blown away many of the questions were WAY over my head. I don't really know how I scored with the attendees of that session but I do know it took a few years to be accepted to speak at any future conferences.

The big benefit was I had the conference on my resume, I started looking for a new job one that would allow me to expanding my programming abilities and pay more. I had 5 different job offers, I took a job with a local consulting company which more than doubled my current pay. It was an awesome job because the Delphi market was huge. I worked for so many different clients in the next two years I lost count. I specialized in going into new locations that was experiencing bugs in there code and helping them debug there code and resolve what appeared to be random access violation errors. During this time I took over as the President of the Salt Lake City Delphi users group, which I still do to this day.

In 1998 my life was changing even more, I had found the love of my life and was married. At the same time I could see the market for Delphi opportunities was starting to dry up, so I took something more stable, or so I thought. I then took two jobs in a row where I was laid off as business directions changed. After the second lay off I decided the consulting business was just as stable and paid more. I had a three clients, the State of Utah, Borland, and a small embedded software developer. The Borland contract, was awesome I was working with some of the people I had admired over the years. However at one point in 2005 all three clients were asking for my services at least full time at the same time. Instead of refusing work, I tried to keep it up, but after about 4 months I crashed and burned. It took months to fully recover, I was forced to quit all but one of the contracts. The one contract I kept was with the State of Utah, they offered me a full time job, which I accepted and still work there to this day.

In July of 2008 I finally enrolled in school again to finish that degree that. Schools no longer teach pascal, so I have been using JavaScript, and Java. But after many assignments Delphi it is still my development product of choice.

Just imagine the number of people that have been supported by income generated from working with Delphi. Delphi has supported my family from the beginning and hopefully well into the future.

To the point... I want to wish a happy 15th Birthday to Delphi. I want to thank all of the people behind the product for the dramatic way they have affected my life!

Secondary point of the story:
In 15 years I have personally been responsible for purchases of more than 100 different licenses of Delphi. If I had not been able to afford Turbo Pascal, I would have been forced to go another direction. My entry level investment in 1990's in Turbo Pascal resulted in way over 100k of Delphi revenue stream. It's time to find away back into the entry level market.

An Object Binding Prototype

2010-01-28T19:43:00.001-07:00

I have been really looking for good ways to keep the different layers of our application bound together. As such I have been looking at others code, searching out libraries, and building prototypes.

One such prototype I have built, is fairly simple. While, I am not sold on using this as a method for binding, I think its worth sharing. It requires Delphi 2010, and uses the enhanced
RTTI.

First off the TObjectBinder code can be downloaded from SVN Repository in my RTTIWork Branch.

Say you have class such as this one:

TPerson = class(TObject)
  FirstName : String;
  LastName : String;
end;

To use this code all you need to tie this object to your user interface is this:

  // Create Binding with Class you want as the source of the binding
  Binding := TObjectBinder.Create(TPerson);
  // Binding() Parameters
  // First: Property or Field of Class passed to the Constructor
  // Second: Object you want as the destination of the binding.
  // Third:  Property or Field of the Destination you want to bind too
  // Fourth: If the binding is readonly(Optional: Default False)
  // Fifth: ITypeMapping Interface (Optional: Default NIL) more on this later.
  Binding.Binding('FirstName',Edit1,'Text');
  Binding.Binding('LastName',Edit2,'Text');
  // Then there are two key methods you can use after that.
  // Load() takes the contents of the Person and populates
  //        Edit1 and Edit2 Controls
  Binding.Load(Person); // Where Person is an instance of TPerson
  // This takes the contents of Edit1 and Edit2 and Saves it back to the person.
  Binding.Save(Person);

What does this offer, allows you create a list of bindings of any property of any object
to any other property of any object. It reduces code like this...

  Edit1.Text := Person.FirstName;
  Edit2.Text := Person.LastName;
  ...
  Person.FirstName := Edit1.Text;
  Person.LastName := Edit1.Text;

I have buttons that need to be enabled only when the data changes, so I also implemented

Button1.Enabled := Binding.IsChanged(Person);

Since mappings may need to change data types, I created the following interface
to allow you to specify conversion methods and supply them.

  ITypeMapping = interface
     function SourceToDest(Source : TValue) : TValue;
     function DestToSource(Source : TValue) : TValue;
     function Compare(Source : TValue; Dest : TValue) : Integer;
  end;

Granted, if this was more than a prototype I would have built all of the common conversions
and automatically detected which one to use.

To take this further, I have a need to dynamically create a form that can edit an unknown object. Similar to what you can do with an Object Inspector, so this might work well to bind
to those dynamically create controls. Time to build another prototype :-)

Special thanks to Cobus Kruger for this great post and another option on doing the same thing. In that solution, I did not like having to name my controls to have to match my model. But the basic idea is very similar, and shows off yet another way to use the RTTI and potentially solve the same problem.

RTTI & XmlSerial.pas Refactoring - SVN Changes

2009-10-14T03:33:00.005-06:00

XmlSerial.pas started as really cool demo of what you can do with RTTI in Delphi 2010. Most of the time demo code is an example that should be looked at learned from and thrown away.

The problem I face is that I need XmlSerial to be far more than a Demo. I need a fully functional serializer that will inter-op with classes using the .NET XmlSerializer.

After committing a couple of my refactoring changes to make it more than just a demo. I realized that I did not want to keep committing all of my changes to the SVN
Trunk.
I really want to keep committing code each day that may not even remotely work. I have some major changes in design planned that will require that for a few days.

So as such I just created a branch for my RTTI work if you want to follow that work, while I refactor to provide an elegant and far more supportable framework. When this work stabilizes I will merge the changes back to Trunk.

Here are the few things that I intend to do to the code:

For example, I intend to create an Adapter for XML Parsing to allow current use of TxmlDocument to continue, but also allow for other types of Parsing that may not be DOM based to work. Specifically I am doing this because, I am concerned with the speed and memory footprint that is required by DOM.

I also want to create a set of adapters and factory that will allow things like TList, Dynamic Arrays and TDataset all to look the same to the serialization engine, so I don't have to write custom code in multiple places. Instead I can just delegate that functionality to a class that will hide the implementation details of how the data is stored. I can see this work being used in a variety of applications outside of XML Serialization.

Do you have specific needs for XML Serialization? I would like to know as now is the time to see if I can address them.

Xml Serialization - Control via Attributes

2009-10-08T17:00:00.005-06:00

The XmlSerial.pas unit now supports the Attributes. I had to fix a couple of bugs to get it working, just in case you grabbed the copy I posted earlier today.

Now you can use 4 Different attributes to control XML serialization process. Specifically XmlRoot, XmlElement, XmlAttribute, and XmlIgnore. I modified the original class I used in the previous XML serialization post to use these.


  [XmlRoot('Person')]
  TPerson = class(TObject)
  private
    FLastName: String;
    FBirthday: TDateTime;
    FMiddleName: String;
    FFirstName: String;
    function GetFullName: String;
   published
   public
     [XmlAttribute('First_Name')]
     property FirstName : String read FFirstName write FFirstName;
     [XmlElement('LAST_NAME')]
     property LastName  : String read FLastName  write FLastName;
     [XmlIgnore]
     property MiddleName : String read FMiddleName write FMiddleName;
     property FullName : String read GetFullName;
     property Birthday : TDateTime read FBirthday write FBirthday;
     procedure Save(FileName : String);
     class function Load(FileName : String) : TPerson;
   end;

And now the XML that it outputs and imports is:


<Person First_Name="John">
   <LAST_NAME>Doe</LAST_NAME>
   <Birthday>34744</Birthday>
</Person>

So basically this mimics the behavior of the same attributes in the XML .NET Serialization. Although, it does not support namespaces yet.

RTTI Article List

Xml Serialization - Basic Usage

2009-10-08T07:56:00.008-06:00

This post relates to XmlSerial.pas which provides XML serialization and de-serialization using the new RTTI in Delphi 2010.

This class has been built to serialize any public and published property or Field.
This was done to mimic the behavior found in the .NET Xml Serialization with the goal of having a set of objects that can serialize in .NET using Delphi Prism and Win32 using Delphi 2010. The complete goals of what I want to accomplish with XmlSerial.pas look at the source code, I detailed out what still needs to be done.

There are two ways to work with the Xml Serialization, one depends on a Pointer to the Type Information, the other uses Generics to get it form the type specified as a parameter.


// Method 1:
var
 o : TypeIWantToSerailze;
 s : TXmlTypeSerializer;
 x : TXmlDocument;
 v : TValue;
begin
  s := TXmlTypeSerializer.create(TypeInfo(o));
  x := TXmlDocument.Create(Self); // NEVER PASS NIL!!!
  s.Serialize(x,o);
  x.SaveToFile('FileName.txt');
  v := s.Deserialize(x);
  o := v.AsType<TypeIWantToSerailze>;
  x.free;
  s.free;
end;

// Method 2:
var
 o : TypeIWantToSerailze;
 s : TXmlSerializer<TypeIWantToSerailze>;
 x : TXmlDocument;
begin
  s := TXmlTypeSerializer<TypeIWantToSerailze>.create;
  x := TXmlDocument.Create(Self); // NEVER PASS NIL!!!
  s.Serialize(x,o);
  x.SaveToFile('FileName.txt');
  o := s.Deserialize(x);
  x.free;
  s.free;
end;

And here is the full code showing how to do this using the generic version.


unit uPerson;
interface

type
  TPerson = class(TObject)
  private
    FLastName: String;
    FBirthday: TDateTime;
    FMiddleName: String;
    FFirstName: String;
    function GetFullName: String;
   published
   public
     property FirstName : String read FFirstName write FFirstName;
     property LastName  : String read FLastName  write FLastName;
     property MiddleName : String read FMiddleName write FMiddleName;
     property FullName : String read GetFullName;
     property Birthday : TDateTime read FBirthday write FBirthday;
     procedure Save(FileName : String);
     class function Load(FileName : String) : TPerson;
   end;


implementation
uses
 XmlDoc,
 Classes,
 XmlSerial;

{ TPerson }

function TPerson.GetFullName: String;
begin
 result := FFirstName + ' ' + FMiddleName + ' ' + FLastName;
end;

class function TPerson.Load(FileName: String): TPerson;
var
  lSerialize : TXmlSerializer<TPerson>;
  lOwner : TComponent;
  lDoc   : TxmlDocument;
begin
  lOwner := TComponent.Create(nil);  // Required to make TXmlDocument work!
  try
    lDoc := TXmlDocument.Create(lOwner);  // will be freed with lOwner.Free
    lDoc.LoadFromFile(FileName);
    lSerialize := TXmlSerializer<TPerson>.Create;
    try
      result := lSerialize.Deserialize(lDoc);
    finally
      lSerialize.Free;
    end;
  finally
    lOwner.Free;
  end;
end;

procedure TPerson.Save(FileName: String);
var
  lSerialize : TXmlSerializer<TPerson>;
  lOwner : TComponent;
  lDoc   : TxmlDocument;
begin
  lOwner := TComponent.Create(nil);  // Required to make TXmlDocument work!
  try
    lDoc := TXmlDocument.Create(lOwner);  // will be freed with lOwner.Free
    lSerialize := TXmlSerializer<TPerson>.Create;
    try
      lSerialize.Serialize(lDoc,Self);
      lDoc.SaveToFile(FileName);
    finally
      lSerialize.Free;
    end;
  finally
    lOwner.Free;
  end;
end;

end.

The project that shows how to use this object.


program Project12;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  Windows,
  XmlSerial,
  Forms,
  uPerson in 'uPerson.pas';

var
  P : TPerson;

begin
  Application.Initialize;
  P := TPerson.Create;
  try
   P.FirstName := 'John';
   P.MiddleName := 'C';
   P.LastName := 'Doe';
   P.Birthday := EncodeDate(1995,2,14);
   P.Save('C:\test.xml');
  finally
    P.Free;
  end;

  p := TPerson.Load('C:\test.xml');
  try
    writeln(P.FullName);
    Writeln(DateToStr(P.Birthday));
    Readln;
  finally
    p.Free;
  end;
end.

Output:


John C Doe
2/14/1995

Current output of the XML file, notice the Date, it's something I want to change, if you check the roadmap in the xmlserial.pas source.


<TPerson>
   <FirstName>John</FirstName>
   <LastName>Doe</LastName>
   <MiddleName>C</MiddleName>
   <Birthday>34744</Birthday>
</TPerson>

Hopefully this covers enough of how to use this to get you started.
I will show how to customize the behavior using attributes in a future post.

RTTI Article List

INI persistence the RTTI way

2009-10-08T06:05:00.012-06:00

This post is based around the IniPersit.pas code that I just released.

I commonly create configuration classes to create a common and easy way to access information stored in INI, Registry, or XML. In these examples I will show how I used the new RTTI and Attributes in Delphi 2010 to provide a new way of creating a configuration class that access information stored in an INI file.

Lets first start off showing how to use the New Unit, then we can pull back the covers and show how it works.


unit ConfigSettings;
interface
uses
  IniPersist;

type
  TConfigSettings = class (TObject)
  private
    FConnectString: String;
    FLogLevel: Integer;
    FLogDirectory: String;
    FSettingsFile: String;
  public
    constructor create;
    // Use the IniValue attribute on any property or field
    // you want to show up in the INI File.
    [IniValue('Database','ConnectString','')]
    property ConnectString : String read FConnectString write FConnectString;
    [IniValue('Logging','Level','0')]
    property LogLevel : Integer read FLogLevel write FLogLevel;
    [IniValue('Logging','Directory','')]
    property LogDirectory : String read FLogDirectory write FLogDirectory;

    property SettingsFile : String read FSettingsFile write FSettingsFile;
    procedure Save;
    procedure Load;

  end;

implementation
uses SysUtils;

{ TApplicationSettings }

constructor TConfigSettings.create;
begin
  FSettingsFile := ExtractFilePath(ParamStr(0)) +  'settings.ini';
end;

procedure TConfigSettings.Load;
begin
// This loads the INI File Values into the properties.
   TIniPersist.Load(FSettingsFile,Self);
end;

procedure TConfigSettings.Save;
begin
// This saves the properties to the INI
   TIniPersist.Save(FSettingsFile,Self);
end;

end.


program Project13;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  IniPersist,
  ConfigSettings;

var
  Settings : TConfigSettings;

begin
    Settings := TConfigSettings.Create;
    try
      Settings.ConnectString := '\\127.0.0.1\DB:2032';
      Settings.LogLevel := 3;
      Settings.LogDirectory := 'C:\Log';
      Settings.Save;
    finally
      Settings.Free;
    end;

    Settings := TConfigSettings.Create;
    try
    Settings.Load;
    WriteLn(Settings.ConnectString);
    Writeln(Settings.LogLevel);
    Writeln(Settings.LogDirectory);
    finally
      Settings.Free;
    end;
    Readln;
end.

Output:


\\127.0.0.1\DB:2032
3
C:\Log

Resulting INI File:


[Database]
ConnectString=\\127.0.0.1\DB:2032
[Logging]
Level=3
Directory=C:\Log

As you can see by the above code there really is not much too it, if you want a field or a property to be stored in the INI File, you just need to add the IniValue Attribute.


  TExampleClass = class (TObject)
  private
    FConnectString: String;
  public
    [IniValue('Database','ConnectString')]
    property ConnectString : String read FConnectString write FConnectString;
  end;

The constructor of the INIValue allows you to specify the Section, Name you the field or Property stored in. It also allows you to specify a default value if the name & section did not exist in the INI File.


  IniValueAttribute = class(TCustomAttribute)
  private
    FName: string;
    FDefaultValue: string;
    FSection: string;
  published
     constructor Create(const aSection : String;const aName : string;const aDefaultValue : String = '');
     property Section : string read FSection write FSection;
     property Name : string read FName write FName;
     property DefaultValue : string read FDefaultValue write FDefaultValue;
  end;

...

constructor IniValueAttribute.Create(const aSection, aName, aDefaultValue: String);
begin
  FSection := aSection;
  FName := aName;
  FDefaultValue := aDefaultValue;
end;

So the magic is really contained in TIniPersist


  TIniPersist = class (TObject)
  private
    class procedure SetValue(aData : String;var aValue : TValue);
    class function GetValue(var aValue : TValue) : String;
    class function GetIniAttribute(Obj : TRttiObject) : IniValueAttribute;
  public
    class procedure Load(FileName : String;obj : TObject);
    class procedure Save(FileName : String;obj : TObject);
  end;

The load and save methods are nearly identical, so lets take a look at load.


class procedure TIniPersist.Load(FileName: String; obj: TObject);
var
 ctx : TRttiContext;
 objType : TRttiType;
 Field : TRttiField;
 Prop  : TRttiProperty;
 Value : TValue;
 IniValue : IniValueAttribute;
 Ini : TIniFile;
 Data : String;
begin
 ctx := TRttiContext.Create;
 try
   Ini := TIniFile.Create(FileName);
   try
     objType := ctx.GetType(Obj.ClassInfo); 
     for Prop in objType.GetProperties do
     begin
       IniValue := GetIniAttribute(Prop);
       if Assigned(IniValue) then
       begin
          Data := Ini.ReadString(IniValue.Section,IniValue.Name,IniValue.DefaultValue);
          Value := Prop.GetValue(Obj);
          SetValue(Data,Value);
          Prop.SetValue(Obj,Value);
       end;
     end;
     for Field in objType.GetFields do
     begin
       IniValue := GetIniAttribute(Field);
       if Assigned(IniValue) then
       begin
          Data := Ini.ReadString(IniValue.Section,IniValue.Name,IniValue.DefaultValue);
          Value := Field.GetValue(Obj);
          SetValue(Data,Value);
          Field.SetValue(Obj,Value);
       end;
     end;
   finally
     Ini.Free;
   end;
 finally
   ctx.Free;
 end;
end;

So you can see we basically loop through all the properties and field check for an Attribute, if it exists we get the current value which sets the TypeInfo in the TValue object. Then we assign the string returned from the INI file into the TValue and call SetValue()

Lets look at the two methods called.


  class procedure SetValue(aData : String;var aValue : TValue);
  class function GetIniAttribute(Obj : TRttiObject) : IniValueAttribute;

Lets look first at SetValue(). You will see that it depends on the TypeInfo being present in the TValue being passed in. We check the TValue and perform the conversions required to convert the String to the Correct Type before storing it
into the TValue.


class procedure TIniPersist.SetValue(aData: String;var aValue: TValue);
var
 I : Integer;
begin
 case aValue.Kind of
   tkWChar,
   tkLString,
   tkWString,
   tkString,
   tkChar,
   tkUString : aValue := aData;
   tkInteger,
   tkInt64  : aValue := StrToInt(aData);
   tkFloat  : aValue := StrToFloat(aData);
   tkEnumeration:  aValue := TValue.FromOrdinal(aValue.TypeInfo,GetEnumValue(aValue.TypeInfo,aData));
   tkSet: begin
             i :=  StringToSet(aValue.TypeInfo,aData);
             TValue.Make(@i, aValue.TypeInfo, aValue);
          end;
   else raise EIniPersist.Create('Type not Supported');
 end;
end;

Now lets take a look at GetIniAttribute() the goal of this method is to check to see if a given TRttimember (Field or Property) has the IniValue attribute, and if it does return it, otherwise return NIL.


class function TIniPersist.GetIniAttribute(Obj: TRttiObject): IniValueAttribute;
var
 Attr: TCustomAttribute;
begin
 for Attr in Obj.GetAttributes do
 begin
    if Attr is IniValueAttribute then
    begin
      exit(IniValueAttribute(Attr));  // Exit with a parameter new in Delphi 2010
    end;
 end;
 result := nil;
end;

So all in all, its really not much code, and it make usage simple. Now granted TIniValue is not all that complex, but this situation could be applied to a variety of other applications.

RTTI Article List

RTTI - Practical Examples

2009-10-08T05:51:00.003-06:00

Well it took a lot longer than I wanted to get this code out.

There were many more rough edges than I wanted, but after some gentle and firm requests I realized I needed to get this out before the rough edges are finished.

Specifically the XmlSerial.pas has a road map in source code detailing what I still need to get done.

What is released:

IniPersist.pas Allows easy mapping of properties and fields to an INI File.

XmlSerial.pas Object and Record Serialization and De-serialization to XML

ObjDs.pas Read-only mapping of Objects to TClientDataSets.

RttiUtils.pas Things to help with common RTTI needs.

How to get the code:
Follow the above links to each unit, or just use SVN.

I am now working on some blog posts to show the how to use this code.

TValue in Depth

2009-09-22T14:25:00.006-06:00

TValue is one of the key Types in the new RTTI System. We already covered some of the basics in the introduction to TValue. It's now time to pull back the covers and explorer how it was designed so you can exploit the entire power of TValue.

Before we get too far, lets take a look at the field in the interface of TValue.


  TValue = record
   ... 
  private
    FData: TValueData;
  end;

Since TValue can store data from any type. I was interested in how this accomplished, it proved useful
in determining how to store data from various unknown types I knew I would be throwing at it in the future.

TValueData is defined as:


  TValueData = record
    FTypeInfo: PTypeInfo;
    // If interface, then a hard-cast of interface to IInterface.
    // If heap data (such as string, managed record, array, etc.) then IValueData
    // hard-cast to IInterface.
    // If this is nil, then the value hasn't been initialized and is empty.
    FHeapData: IInterface;
    case Integer of
      0: (FAsUByte: Byte);
      1: (FAsUWord: Word);
      2: (FAsULong: LongWord);
      3: (FAsObject: TObject);
      4: (FAsClass: TClass);
      5: (FAsSByte: Shortint);
      6: (FAsSWord: Smallint);
      7: (FAsSLong: Longint);
      8: (FAsSingle: Single);
      9: (FAsDouble: Double);
      10: (FAsExtended: Extended);
      11: (FAsComp: Comp);
      12: (FAsCurr: Currency);
      13: (FAsUInt64: UInt64);
      14: (FAsSInt64: Int64);
      15: (FAsMethod: TMethod);
  end;

It's just a variant record, that takes 24 bytes of memory.

The key parts are FTypeInfo, and then either FHeapData or one of the variant parts
would be use to store the data.

Knowing this how this is stored helps in understanding the low level routines to set and access
the data stored in a TValue.


  TValue = record
    ...
  public
    ...
    // Low-level in
    class procedure Make(ABuffer: Pointer; ATypeInfo: PTypeInfo; out Result: TValue); overload; static;
    class procedure MakeWithoutCopy(ABuffer: Pointer; ATypeInfo: PTypeInfo; out Result: TValue); overload; static;
    class procedure Make(AValue: NativeInt; ATypeInfo: PTypeInfo; out Result: TValue); overload; static;
    
    // Low-level out
    property DataSize: Integer read GetDataSize;
    procedure ExtractRawData(ABuffer: Pointer);
    // If internal data is something with lifetime management, this copies a 
    // reference out *without* updating the reference count.
    procedure ExtractRawDataNoCopy(ABuffer: Pointer);
    function GetReferenceToRawData: Pointer;
    function GetReferenceToRawArrayElement(Index: Integer): Pointer;
    ...
  end;

Basically, you can use Make() to place any data with type information into a TValue.

Here is an example that placed an Integer and TRect in


program Project12;
{$APPTYPE CONSOLE}
uses SysUtils, Windows, TypInfo,Rtti;

var
  IntData : Integer;
  IntValue : TValue;

  RecData : TRect;
  RecValue : TValue;

begin
  IntData := 1234;
  //Granted it's easier to call IntValue := IntData;  but this is an example.
  TValue.Make(@IntData,TypeInfo(Integer),IntValue);
  Writeln(IntValue.ToString);
  RecData.Left := 10;
  RecData.Right := 20;
  TValue.Make(@RecData,TypeInfo(TRect),RecValue);
  Writeln(RecValue.ToString);
  readln;
end.

Output:


1234
(record)

When dealing with Deserialization issues I realized I had to recreate record structures when I did not know anything but the TypeInfo. This can be done by calling:


TValue.Make(nil,TypeInfoVar,OutputTValue);

Extracting data can also be done using the low level routines, here is an example of using ExtractRawData.


program Project12;
{$APPTYPE CONSOLE}
uses SysUtils, Windows, TypInfo,Rtti;

var
  RecData : TRect;
  RecDataOut : TRect;
  RecValue : TValue;

begin
  RecData.Left := 10;
  RecData.Right := 20;
  TValue.Make(@RecData,TypeInfo(TRect),RecValue);

  RecValue.ExtractRawData(@RecDataOut);
  Writeln(RecDataOut.Left);
  Writeln(RecDataOut.Right);

  readln;
end.

Output:


10
20

You can use things like GetReferenceToRawData() with the SetValue and GetValue on records.


program Project12;
{$APPTYPE CONSOLE}
uses SysUtils, Windows, TypInfo,Rtti;

var
  RecData : TRect;
  RecValue : TValue;
  Ctx : TRttiContext;

begin
  Ctx := TRttiContext.Create;
  // Create empty record structure
  TValue.Make(nil,TypeInfo(TRect),RecValue);
  // Set the Left and Right Members, using the pointer to the Record
  Ctx.GetType(TypeInfo(TRect)).GetField('Left').SetValue(RecValue.GetReferenceToRawData,10);
  Ctx.GetType(TypeInfo(TRect)).GetField('Right').SetValue(RecValue.GetReferenceToRawData,20);
  // Extract the record to report the results.
  RecValue.ExtractRawData(@RecData);
  Writeln(RecData.Left);
  Writeln(RecData.Right);
  readln;
  Ctx.Free;
end.

Output:


10
20

These little examples show how to deal with types that you don't know about at compile time. However, sometimes you do know the type you will be working with at compile time. When this is know it becomes much easier to to work with using a the Generic/Parametrized Type functions that TValue Provides:


    class function From<T>(const Value: T): TValue; static;
    function AsType<T>: T;
    function TryAsType<T>(out AResult: T): Boolean;
    function Cast<T>: TValue; overload;

The following example shows From<T>() IsType<T>() and AsType<T>() in use.


program Project12;
{$APPTYPE CONSOLE}
uses SysUtils, Windows, TypInfo,Rtti;

var
  RecData : TRect;
  RecDataOut : TRect;
  RecValue : TValue;
begin
  RecData.Left := 10;
  RecData.Right := 20;

  RecValue := TValue.From<TRect>(RecData);

  Writeln(RecValue.IsType<TRect>);

  RecDataOut := RecValue.AsType<TRect>;

  Writeln(RecDataOut.Left);
  Writeln(RecDataOut.Right);
  readln;
end.

Output:


TRUE
10
20

There are also other function on TValue that help you with Array Types.


    function GetArrayLength: Integer;
    function GetArrayElement(Index: Integer): TValue;
    procedure SetArrayElement(Index: Integer; const AValue: TValue);

It should be noted that dynamic arrays that are declared like this are currently not
supported:


Var
  IntArray : Array of Integer;

But if you can your code to be like this they work fine.


type 
  TIntArray = Array of Integer;

var 
  I : TIntArray;
  // or
  I : TArray<Integer>; {defined in System.pas as:   TArray<T> = array of T;}

Another small gotcha is that TValue.FromVariant() is misleading.

I thought it meant that I would be taking a Variant and stuffing it into the TValue, however you will find that it really is not doing that, it's storing the data using originating type, the following code shows how it behaves.


program Project12;
{$APPTYPE CONSOLE}
uses SysUtils, TypInfo,Rtti;

var
  vExample : Variant;
  Value : TValue;
begin
  vExample := 'Hello World';
  Value := TValue.FromVariant(vExample);
  writeln(GetEnumName(TypeInfo(TTypeKind),Ord(Value.Kind)));
  Writeln(value.ToString);

  vExample := 1234;
  Value := TValue.FromVariant(vExample);
  writeln(GetEnumName(TypeInfo(TTypeKind),Ord(Value.Kind)));
  Writeln(value.ToString);

  readln;
end.

Output:


tkUString
Hello World
tkInteger
1234

If you want to store a Variant into a TValue you can use this method


program Project12;
{$APPTYPE CONSOLE}
uses SysUtils, TypInfo,Rtti;

var
  vExample : Variant;
  Value : TValue;
begin
  vExample := 'Hello World';
  Value := TValue.From(vExample);
  writeln(GetEnumName(TypeInfo(TTypeKind),Ord(Value.Kind)));
  Writeln(value.AsType);

  vExample := 1234;
  Value := TValue.From(vExample);
  writeln(GetEnumName(TypeInfo(TTypeKind),Ord(Value.Kind)));
  Writeln(value.AsType);

  readln;
end.

Output:


tkVariant
Hello World
tkVariant
1234

There are also other ways to work with TValue that I just don't have the time to cover. I recommend opening up Rtti.pas and exploring the interface to see everything that is available. The items I failed to cover are fairly straight forward.

I hope this give's you a good taste of how TValue works.

RTTI Article List

Exploring TRttiMember Descendants in depth (Part II) Methods

2009-09-17T12:37:00.005-06:00

Today I will be covering TRttiMethod. it is the biggest reason I am so happy with the new RTTI in Delphi 2010. In prior versions of Delphi dynamic method invocation was a black art, that had many limitations. It was painful and was dependent on how your code was compiled. The default behavior of the VCL classes had it disabled. Prior to Delphi 2010 you had to know way too much about the internals of method information structure {$METHODINFO}, to invoke a method dynamically.

Now in Delphi 2010 with default behavior is that RTTI Information for methods is generated for the public and published sections. I don't need to know a thing about how the RTTI information is being stored. There is a very elegant and easy to use API to dynamically query and invoke methods. Which works for all the existing VCL classes.

You must understand TRttiMethod and TValue you have the ability to dynamically invoke most any method.

TRttiMethod descends from TRttiMember, besides the Name & Visibility which was defined in TRttiMember, we may need to know many other aspects about a given method.

A few key properties are defined to allow easy access to this information.


TypInfo.pas
  TMethodKind = (mkProcedure, mkFunction, mkConstructor, mkDestructor,
    mkClassProcedure, mkClassFunction, mkClassConstructor, mkClassDestructor,
    mkOperatorOverload,
    { Obsolete }
    mkSafeProcedure, mkSafeFunction);

  TCallConv = (ccReg, ccCdecl, ccPascal, ccStdCall, ccSafeCall);

Rtti.pas

  TDispatchKind = (dkStatic, dkVtable, dkDynamic, dkMessage, dkInterface);

In TRttiMember 
    property MethodKind: TMethodKind read GetMethodKind;
    property DispatchKind: TDispatchKind read GetDispatchKind;

    property CodeAddress: Pointer read GetCodeAddress;
    property IsConstructor: Boolean read GetIsConstructor;
    property IsDestructor: Boolean read GetIsDestructor;
    property IsClassMethod: Boolean read GetIsClassMethod;
    // Static: No 'Self' parameter
    property IsStatic: Boolean read GetIsStatic;

    // Vtable slot for virtual methods.
    // Message index for message methods (non-negative).
    // Dynamic index for dynamic methods (negative).
    property VirtualIndex: Smallint read GetVirtualIndex;
    property CallingConvention: TCallConv read GetCallingConvention;
    property CodeAddress: Pointer read GetCodeAddress;

Now this information is fairly useless if you don't know the parameters of a given method and a possible result type, there is a property and a function to provide you with this information.


    function GetParameters: TArray<TRttiParameter>; virtual; abstract;
    property ReturnType: TRttiType read GetReturnType;

Here is an example of looking at these, it looks at the TStringList.AddObject() Method


program Project12;
{$APPTYPE CONSOLE}
uses
  Classes, Rtti;
var
  ctx : TRttiContext;
  t : TRttiType;
  Param : TRttiParameter;
  AddObjectMethod : TRttiMethod;
begin
  ctx := TRttiContext.Create;
  t := ctx.GetType(TStringList.ClassInfo);
  AddObjectMethod := t.GetMethod('AddObject');
  for Param in AddObjectMethod.GetParameters do
  begin
    Writeln(Param.ToString);
  end;
  Writeln('Returns:', AddObjectMethod.ReturnType.ToString );
  readln;
  ctx.Free;
end.

Output:


S: string
AObject: TObject
Returns:Integer

TRttiParameter is contains the information you need to know about a given parameter.


typInfo.pas
...
  TParamFlag = (pfVar, pfConst, pfArray, pfAddress, pfReference, pfOut, pfResult);
  {$EXTERNALSYM TParamFlag}
  TParamFlags = set of TParamFlag;
...

Rtti.pas

TRttiNamedObject
...
    property Name: string read GetName;
...

TRttiParameter = class(TRttiNamedObject)
...
    function ToString: string; override;
    property Flags: TParamFlags read GetFlags;
    // ParamType may be nil if it's an untyped var or const parameter.
    property ParamType: TRttiType read GetParamType;
...

Now that you have access to the information for a given method you can call it.

In this example you can see two calls, on to constructor and another to the Add() method of TStringList.


program Project12;
{$APPTYPE CONSOLE}
uses
  Classes, Rtti, TypInfo;
var
  ctx : TRttiContext;
  t : TRttiType;
  Param : TRttiParameter;
  AddMethod : TRttiMethod;
  SL : TValue; // Contains TStringList instance
  
begin
  ctx := TRttiContext.Create;
  t := ctx.GetType(TStringList.ClassInfo);
  // Create an Instance of TStringList
  SL := t.GetMethod('Create').Invoke(t.AsInstance.MetaclassType,[]);
  // Invoke "Add" and return string representatino of result.
  Writeln(t.GetMethod('Add').Invoke(SL,['Hello World']).ToString);
  // Write out context.
  Writeln((sl.AsObject as TStringList).Text);
  readln;
  ctx.Free;
end.

Output:


0
Hello World

There are three overloaded versions of Invoke


    function Invoke(Instance: TObject; const Args: array of TValue): TValue; overload;
    function Invoke(Instance: TClass; const Args: array of TValue): TValue; overload;
    function Invoke(Instance: TValue; const Args: array of TValue): TValue; overload;

In the above example you can see I used the TValue and TClass versions, now lets look at a more complex situation using the last overload.

When dealing with method calls that update the parameters, such as those declared with the "var" syntax, the the original array you pass in of parameters is updated with the correct changes.

This program demonstrates how this works:


program Project12;
{$APPTYPE CONSOLE}
uses
  Classes, Rtti, TypInfo;
const
 AreYouMyMotherISBN = '0-679-89047-5';
type
  TBookQuery = class(TObject)
  public
    function FindBook(ISBN : String;var Title : String) : Boolean;
  end;

  function TBookQuery.FindBook(ISBN : String;var Title : String) : Boolean;  
  begin
    Writeln('Checking:',ISBN);
    // Find one of the books, I get to read every night :-)
    if ISBN = AreYouMyMotherISBN then
    begin
      result := true;
      Title := 'Are you my Mother?'
    end
    else 
    begin
      Title := '';
      result := false;
    end;  
  end;
  
var
  ctx : TRttiContext;
  BQ : TBookQuery;
  Args : Array Of TValue;
  Param : TRttiParameter;
  FindBook : TRttiMethod;
  SL : TValue; // Contains TStringList instance
  
begin
  ctx := TRttiContext.Create;
  BQ := TBookQuery.Create;
  FindBook := Ctx.GetType(TBookQuery.ClassInfo).GetMethod('FindBook');

  SetLength(args,2);
  Args[0] := '123';  // an ISBN that won't be found
  Args[1] := '';
  

  // Invoke the Method  
  if FindBook.Invoke(BQ,Args).AsBoolean then
   writeln(args[1].ToString)
  else
   writeln('Not Found');

  SetLength(args,2);
  Args[0] := AreYouMyMotherISBN;  // an ISBN that will be found
  Args[1] := '';   

  // Invoke the Method
  if FindBook.Invoke(BQ,Args).AsBoolean then
   writeln(args[1].ToString)
  else
   writeln('Not Found');
   

  readln;
  BQ.Free;  
  ctx.Free;
end.

Output:


Checking:123
Not Found
Checking:0-679-89047-5
Are you my Mother?

Updated:
Well I neglected to be complete when it came to how you can query and access TRttiMethods. I only showed "GetMethod()" on TRttiType but there are four
ways to get information.


    // Get's all of the methods on a given class, with the declared ones first.
    function GetMethods: TArray<TRttiMethod>; overload; virtual; 
    // Will return the first method it finds with the given name
    function GetMethod(const AName: string): TRttiMethod; virtual;
    // Will return all of the methods it finds with a given method, so you can deal with overloads.
    function GetMethods(const AName: string): TArray<TRttiMethod>; overload; virtual;
    // Will only get methods declared on the given class, and not on parents.
    function GetDeclaredMethods: TArray<TRttiMethod>; virtual;

That's really all there is to using TRttiMethod, if you tried to do this in a prior version of Delphi I am sure you will be very happy with the changes. If you never tried don't, just move to Delphi 2010 and use the new functionality. Now you might be why would I use this, well hopefully you will get a taste of that in the practical application articles that are coming soon. However, in my next Article I will cover TValue in Depth.

RTTI Article List

TRttiContext.Create() & TRttiContext.Free()

2009-09-16T08:09:00.008-06:00

I thought I needed to take a break from the normal articles to explain why I call
TRttiContext.Create() and TRttiContext.Free() when in fact you don't need too.

Yes you don't need to do it, but yet I do... Why?

First off lets look at the implementation of both.


class function TRttiContext.Create: TRttiContext;
begin
 Result.FContextToken := nil;
end;

procedure TRttiContext.Free;
begin
 FContextToken := nil;
end;

At first glance there is nothing special, FContextToken is set to NIL in both cases.

So what does setting FContextToken to NIL really do?

We all know that Delphi currently does not have any Garbage collection mechanism. As such having a rich RTTI library that is based on Objects could be problematic.

In my code an I able to such cool things as...

c.GetType().GetField().FieldType.ToString

Without having to set temporary values for each returned object, to free them.
How is this possible without a garbage collector?

Well under the hood you will find TRttiPool that contains all of the RTTI object that are created.
When this pool is freed all of the objects created during RTTI calls are then freed.

The construction and destruction of this pool is controlled by TPoolToken which is the Interface that is stored in FContextToken.

When the TPoolToken is created and freed, the PoolRefCount is maintained, when it reaches zero the TRttiPool is freed.

So why call .Create() and .Free()

So lets start with .Create()

So it's not like calling this code is a huge overhead, yes sure a record is managed and as such it will be initialized, making the call to set FContextToken redundant. well sort of... Although I don't intend every create a pointer to TRttiContext, its possible have the memory space not be initialized as expected, unless you are calling .Create.

I also can't be sure that the implementation will remain as simple. It is very possible that additional code could be called at this point. Keeping my code safe in the future is always critical to me in my designs.

Moving on to .Free()

Well, I like to keep my memory foot print clean. Sure when the TRttiContext variable goes out of scope the exact same behavior will occur.

Very early on when playing with new RTTI I inadvertently caused an access violation in a TCustomAttribute Descendant destructor. With the call to .free() it was easier to see what had caused the problem. Instead of having it occur after the destruction of the Object that had the TRttiContext declared as a field.

And just to stop the obvious comment.... Yes, I know the documentation say's you don't have to call .Free() And implies that the technique is important because it insures that all RTTI Objects are cached and reused, well this would only be true of TRttiContext was declared as a global variable, which I think is a very BAD idea.

Instead I think you should keep your TRttiContext around as long as you need it, but free it when the time is correct.

In short... I find it a matter of personal preference.

Exploring TRttiMember Descendants in depth (Part I) Properties and Fields

2009-09-15T16:24:00.002-06:00

Some types such as classes and records contain "members" such as field, properties and methods.

RTTI information starts with the TRttiMember which provides 4 bits of information about each Member.

The name

Visibility (private,protected,public,published)

The type that the member is associated with

Attributes associated with that member

This example code shows how to access each of these.


program Project4;

{$APPTYPE CONSOLE}

uses
  SysUtils, Rtti, TypInfo;

type
  TTest = class(TCustomAttribute)
  end;

  TBook = class(TObject)
  private
    FTitle: String;
  public
    [TTest]
    property Title : String read FTitle write FTitle;
  end;

var
 c : TRttiContext;
 m : TRttiMember;

{ TExample }


begin
  c := TRttiContext.Create;
  m := c.GetType(TBook).GetProperty('Title');
  Writeln('Name:',m.Name);
  Writeln('Visibility:',GetEnumName(TypeInfo(TMemberVisibility),ord(m.Visibility)));
  WriteLn('Parent:',m.Parent.ToString);
  Writeln('First Attribute:',m.GetAttributes[0].ToString);
  writeln;
  m := c.GetType(TBook).GetField('FTitle');
  WriteLn('Name:',m.Name);
  WriteLn('Visibility:',GetEnumName(TypeInfo(TMemberVisibility),ord(m.Visibility)));
  WriteLn('Parent:',m.Parent.ToString);
  readln;
  c.Free;
end.

Output:


Name:Title
Visibility:mvPublic
Parent:TBook
First Attribute:TTest

Name:FTitle
Visibility:mvPrivate
Parent:TBook

The two basic TRttiMember descendants I want to cover in this blog post is TRttiField and TRttiPropery. Both descendants allow you to get and set the values on an Instance of the given type. They both provide SetValue() and GetValue() methods.

The following code demonstrates how to use both. If you missed my Introduction to TValue
I suggest you take some time to read it as it explains some of the "Magic" behind what is going on here.


program Project10;
{$APPTYPE CONSOLE}

uses
  SysUtils, Rtti, TypInfo;

type

  TBook = class(TObject)
  private
    FTitle: String;
  public
    property Title : String read FTitle write FTitle;
  end;

var
 c : TRttiContext;
 p : TRttiProperty;
 f : TRttiField;
 book : TBook;
 v : TValue;
begin
  book := TBook.Create;
  try
    c := TRttiContext.Create;
    
    p := c.GetType(TBook).GetProperty('Title');
    p.SetValue(Book,'Go, Dog, Go!');
    v := p.GetValue(Book);
    Writeln('Title:',v.ToString);

    f := c.GetType(TBook).GetField('FTitle');
    f.SetValue(Book,'Green Eggs and Ham');
    v := f.GetValue(Book);
    Writeln('FTitle:',v.ToString);

    readln;
    
    c.Free;
 
  finally
    Book.Free;
  end;
end.

Output:


Title:Go, Dog, Go!
FTitle:Green Eggs and Ham

With Properties you have to worry about if they are readable or writable, as attempting to call SetValue on a property that is not writable will produce an EPropReadOnly Exception. TRttiProperty has two properties "isReadable" and 'isWritable" that allow you to discover how the property was declared. The following code demonstrates how it works.


program Project10;
{$APPTYPE CONSOLE}

uses
  SysUtils, Rtti, TypInfo;

type

  TBook = class(TObject)
  private
    FTitle: String;
    FUgly: String;
    FAuthor: String;
  public
    property Title : String read FTitle write FTitle; 
    property Author : String read FAuthor;  
    property Ugly : String write FUgly;  
  end;

var
 c : TRttiContext;
 p : TRttiProperty;

begin
  c := TRttiContext.Create;
  try
    p := c.GetType(TBook).GetProperty('Title');
    WriteLn('Name:',p.Name);
    Writeln('IsReadable:',p.IsReadable);
    Writeln('IsWritable:',p.IsWritable);
    writeln;
    p := c.GetType(TBook).GetProperty('Author');
    WriteLn('Name:',p.Name);
    Writeln('IsReadable:',p.IsReadable);
    Writeln('IsWritable:',p.IsWritable);
    writeln;
    p := c.GetType(TBook).GetProperty('Ugly');
    WriteLn('Name:',p.Name);
    Writeln('IsReadable:',p.IsReadable);
    Writeln('IsWritable:',p.IsWritable);
    readln;
  finally
    c.Free;
  end;
end.

Output:


Name:Title
IsReadable:TRUE
IsWritable:TRUE

Name:Author
IsReadable:TRUE
IsWritable:FALSE

Name:Ugly
IsReadable:FALSE
IsWritable:TRUE

That pretty much wraps it up for TRttiField and TRttiProperty, in the next
post I will cover TRttiMethod.

RTTI Article List

Introduction to TValue

2009-09-14T22:54:00.003-06:00

TValue is a new record structure defined in Rtti.pas, it provides the ability to store the value, and type information of an instance of any type. This can be seen in the following code.

For example, in the following program, you can see that the TypeInfo property on
a TValue is the same as the what the TypeInfo() function would return for that type.


program Project10;
{$APPTYPE CONSOLE}

uses
  SysUtils, Rtti;

var
 v : TValue;
 i : Integer;

begin
  i := 10;
  v := I;
  Writeln('Address of TypeInfo on TValue :', IntToStr(Integer(v.TypeInfo)));
  Writeln('Address of TypeInfo on Integer:', IntToStr(Integer(TypeInfo(Integer))));
  Writeln('Value of I:',I);
  Writeln('Value of V:',v.AsInteger);
  readln;
end.

Output:


Address of TypeInfo on TValue :4198560
Address of TypeInfo on Integer:4198560
Value of I:10
Value of V:10

There are several implicit operators defined that allow assignment of these types easy. If you have a type that is not on this list, don't worry there is a way to handle these, it just want to dedicate a single blog post to how to do this.


    class operator Implicit(const Value: string): TValue;
    class operator Implicit(Value: Integer): TValue;
    class operator Implicit(Value: Extended): TValue;
    class operator Implicit(Value: Int64): TValue;
    class operator Implicit(Value: TObject): TValue;
    class operator Implicit(Value: TClass): TValue;
    class operator Implicit(Value: Boolean): TValue;

There are as set of matching functions to get the data out.


    function AsString: string;
    function AsInteger: Integer;
    function AsExtended: Extended;
    function AsInt64: Int64;
    function AsObject: TObject;
    function AsClass: TClass;
    function AsBoolean: Boolean;

Although, this may make you think about the Variant type, conversions from one type to another do not automatically occur. The following code generates an
EInvalidCast Exception, as the stored type is an Integer and not a string.


program Project10;
{$APPTYPE CONSOLE}

uses
  Rtti;

var
 v : TValue;
 i : Integer;

begin
  i := 10;
  v := I;
  // Generates and Invalid Type Cast
  Writeln('Value of V:',v.asString);
  readln;
end.

To help you in determining what type is in a given TValue you have several properties and functions.


 // in TypInfo.pas
 TTypeKind = (tkUnknown, tkInteger, tkChar, tkEnumeration, tkFloat,
    tkString, tkSet, tkClass, tkMethod, tkWChar, tkLString, tkWString,
    tkVariant, tkArray, tkRecord, tkInterface, tkInt64, tkDynArray, tkUString,
    tkClassRef, tkPointer, tkProcedure);

 // part of TValue in rtti.pas
 property Kind: TTypeKind 
 function IsObject: Boolean;  
 function IsType<T>: Boolean; overload;

The following shows each of these:


program Project10;
{$APPTYPE CONSOLE}

uses
  Rtti,TypInfo;

var
 v : TValue;
 i : Integer;

begin
  i := 10;
  v := I;
  Writeln('V.Kind =',GetEnumName(TypeInfo(TTypeKind),ord(v.Kind)));
  Writeln('V.IsType<Integer> = ',v.IsType<Integer>);
  Writeln('V.IsType<TObject> = ',v.IsType<TObject>);
  Writeln('V.IsObject = ',v.IsObject);
  readln;
end.

Output:


V.Kind =tkInteger
V.IsType<Integer> = TRUE
V.IsType<TObject> = FALSE
V.IsObject = FALSE

TValue has a way more functionality to explore, that I will cover in an in depth article later, but the basics needed to be covered before
moving on to TRttiMember for Properties and Fields which is the next article.

RTTI Article List

Exploring TRttiType and descendants in Depth

2009-09-12T08:31:00.004-06:00

TRttiType provides us with an easy to use interface that allows us to the access all of the RTTI Information associated with that type. For the most part, I find this very intuitive, and self documenting, I recommend opening Rtti.pas and looking at the declaration for TRttiType.

I introduced TRttiType in the previous articles.

Like I stated in a prior article, if your type supports, Fields, Properties, and/or Methods. There are a few easy access method to get access to these.

These methods provide access to all of the Fields, Properties, and Methods that have RTTI information, in up coming articles I will go in depth on TRttiField, TRttiProperty, and TRttiMethod.


    function GetMethods: TArray<TRttiMethod>; overload; virtual;
    function GetFields: TArray<TRttiField>; virtual;
    function GetProperties: TArray<TRttiProperty>; virtual;
    
    function GetMethod(const AName: string): TRttiMethod; virtual;
    function GetMethods(const AName: string): TArray<TRttiMethod>; overload; virtual;
    function GetField(const AName: string): TRttiField; virtual;
    function GetProperty(const AName: string): TRttiProperty; virtual;

However, sometimes you one want to access what was declared on that specific type and not in the parent types, this can be done with the following functionality.


    function GetDeclaredMethods: TArray<TRttiMethod>; virtual;
    function GetDeclaredProperties: TArray<TRttiProperty>; virtual;
    function GetDeclaredFields: TArray<TRttiField>; virtual;

If your type supports ancestors, you can get the BaseType through the base type property.
The following code shows how you can walk back up the type tree to find the parent types.


program Project10;

{$APPTYPE CONSOLE}

uses
  SysUtils, RTTI;
type
  TOneObject = Class(TObject)
  end;

  TTwoObject = Class(TOneObject)
  end;

  TThreeObject = Class(TTwoObject)
  end;

var
 c : TRttiContext;
 t : TRttiType;

begin
   c := TRttiContext.Create;
   try
     t := c.GetType(TThreeObject);
     writeln(t.Name);
     while Assigned(t.BaseType) do
     begin
       t := t.BaseType;
       writeln(t.Name);
     end;
   finally
     c.Free
   end;
   readln;
end.

Output:


TThreeObject
TTwoObject
TOneObject
TObject

There are 3 sets of properties that give you more information about the given type.


    property AsInstance: TRttiInstanceType read GetAsInstance;
    property IsInstance: Boolean read GetIsInstance;
    property AsOrdinal: TRttiOrdinalType read GetAsOrdinal;
    property IsOrdinal: Boolean read GetIsOrdinal;
    property IsSet: Boolean read GetIsSet;
    property AsSet: TRttiSetType read GetAsSet;

Instance Types are Classes, and the TRttiInstanceType provides the property "MetaclassType" which returns the TClass for the given type. The following example shows how to use this type to construct an instance of an object.


program Project10;

{$APPTYPE CONSOLE}

uses
  SysUtils, RTTI;
type
  TOneObject = Class(TObject)
  end;

  TTwoObject = Class(TOneObject)
  end;

  TThreeObject = Class(TTwoObject)
  end;

var
 c : TRttiContext;
 t : TRttiType;
 o : TObject;
begin
   c := TRttiContext.Create;
   try
     t := c.GetType(TThreeObject);
     o := t.AsInstance.MetaclassType.Create;
     Writeln(o.ClassName);
     o.Free;
   finally
     c.Free
   end;
   readln;
end.

Output:


TThreeObject

TRttiOrdinalType handles Ordinal Types, such as Integer, Enumerated Type, etc...
It exposes 3 new properties to help you when working with Ordinal types.


    TOrdType = (otSByte, otUByte, otSWord, otUWord, otSLong, otULong);

    ...    

    property OrdType: TOrdType read GetOrdType;
    property MinValue: Longint read GetMinValue;
    property MaxValue: Longint read GetMaxValue;

The following example code shows how they behave.


program Project10;

{$APPTYPE CONSOLE}

uses
  SysUtils, RTTI,TypInfo;
type
  TMyEnum = (enOne,enTwo,enThree);
var
 c : TRttiContext;
 t : TRttiType;
begin
   c := TRttiContext.Create;
   try
     t := c.GetType(TypeInfo(TMyEnum));
     writeln(GetEnumName(TypeInfo(TOrdType),ord(t.AsOrdinal.OrdType)));
     writeln(t.AsOrdinal.MinValue);
     writeln(t.AsOrdinal.MaxValue);
   finally
     c.Free
   end;
   readln;
end.

Output:


otUByte
0
2

Notice, I dipped back into TypInfo.pas to call GetEnumName(), it and it's partner function GetEnumValue(), allow you to work with the names of an enumerated type instead of the ordinal values.

The previous RTTI information that was available in prior versions of Delphi used a pointer to the type information i.e "pTypeInfo"

This is now stored in the .Handle property of the TRttiType, I mention this as the routines in TypInfo.pas still work if you need drop to some lower level functionality.

The TRttiSetType provides one new property "ElementType" which allows you to get the type of the elements of the set. The following code shows an example of this in action.


program Project10;

{$APPTYPE CONSOLE}

uses
  SysUtils, RTTI,TypInfo;
type
  TMyEnum = (enOne,enTwo,enThree);
  TMySet = set of TMyEnum;
var
 c : TRttiContext;
 t : TRttiType;
begin
   c := TRttiContext.Create;
   try
     t := c.GetType(TypeInfo(TMySet));
     Writeln('Element Type:');
     writeln(t.AsSet.ElementType.ToString);
   finally
     c.Free
   end;
   readln;
end.

Output:


Element Type:
TMyEnum

To be complete the following are provided on TRttiType, but TRttiRecordType only provides one new property, ManagedFields, however I have not found a reason I to need this property.


    property AsRecord: TRttiRecordType read GetAsRecord;
    property IsRecord: Boolean read GetIsRecord;

But, don't overlook IsRecord as it's very useful.

There are also several other descendant that you can use the standard "is" and "as" functions on get access to additional information associated with the given type.

TRttiInterfaceType
TRttiInt64Type
TRttiMethodType
TRttiClassRefType
TRttiEnumerationType
TRttiStringType
TRttiAnsiStringType
TRttiFloatType
TRttiArrayType
TRttiDynamicArrayType
TRttiPointerType
TRttiProcedureType

The following code shows how you type cast a TRttiType to a TRttiStringType,
to determine what type of string it's associated with.


program Project10;

{$APPTYPE CONSOLE}

uses
  SysUtils, RTTI,TypInfo;
type
   TmyRecord = record
     UniStr : String;
     AnsiStr : AnsiString;
     WideStr : WideString;
   end;
var
 c : TRttiContext;
 t : TRttiType;
 field : TRttiField;
begin
   c := TRttiContext.Create;
   try
     for field in c.GetType(TypeInfo(TMyRecord)).GetFields do
     begin
       t := field.FieldType;
       writeln('Field:',field.Name);
       writeln('RttiType:',t.ClassName);
       if (t is TRttiStringType) then    
         Writeln('String Kind:',GetEnumName(TypeInfo(TRttiStringKind),ord((t as TRttiStringType).StringKind)));
       Writeln;
     end;
   finally
     c.Free
   end;
   readln;
end.

Output:


Field:UniStr
RttiType:TRttiStringType
String Kind:skUnicodeString

Field:AnsiStr
RttiType:TRttiAnsiStringType
String Kind:skAnsiString

Field:WideStr
RttiType:TRttiStringType
String Kind:skWideString

In conclusion, there are several other small features of TRttiType but I am not trying to reinvent the documentation, so I will leave that for you to discover.

RTTI Article List

Using Attributes and TCustomAttribute descendants

2009-09-11T17:25:00.009-06:00

With Delphi 2010 attributes have been added as a language feature. They have been available in Delphi Prism (Targets .NET) and this now adds similar functionality to Win32.

Attributes are a way of associating additional metadata information with a given type or member of a type.

They can be applied in many places, the following code shows several of the places you can place attributes.


  // Declaring an attribute.
  TAttrTest = class(TCustomAttribute)
  end;

  // Places you can use an attribute.
  [TAttrTest]
  TRec = Record
    [TAttrTest]
    value : String;
    [TAttrTest]
    procedure DoThis([TAttrTest]arg1: String);
  End;

  [TAttrTest]
  TMyEnum = (enOne,enTwo,enThree);

  [TAttrTest]
  TMySet = set of TMyEnum;

  [TAttrTest]
  TObj = class(TObject)
  private
    [TAttrTest]
    FID: Integer;
  public
    [TAttrTest]
    FName : String;
    [TAttrTest]
    property Id : Integer read FID write FID;
    [TAttrTest]
    constructor Create;
    [TAttrTest]
    destructor Destroy; override;
    [TAttrTest]
    procedure DoThis;
  end;

var
  [TAttrTest]
  I : Integer;

So how do attributes work in Delphi 2010?

Attributes must descend from TCustomAttribute, if you look at the declaration of TCustomAttribute you will find that there is nothing special.


{ The base class for all custom attributes. Attribute
instances created by the RTTI unit are owned by those
members to which they apply. }
TCustomAttribute = class(TObject)
end;

Passing just the name of the new attribute is only practical in a few cases, usually
you need additional data associated. This is done through the constructor. The following example shows how to setup the call to the constructor in the attribute.


Type
  TAttrTest2 = class(TObject)
  private
     FId : Integer;
  public
     constructor Create(aID : Integer);
     property ID : Integer read FID write FID;
  end;

  [TAttrTest2(123)]
  TMyObject = Class(TObject)
  end;

So its simple to declare an Attribute and decorate your types with them. Accessing the attributes stored in a given type involves using rtti.pas, I covered some of the basics of how this works in the previous post

Anything that can have attributes has an associated .GetAttributes() method that returns
the array of the attributes associated with that code.

The following code shows how to access the attributes.


program Project10;

{$APPTYPE CONSOLE}

uses
  SysUtils, RTTI;
type
  TAttrTest2 = class(TCustomAttribute)
  private
     FId : Integer;
  public
     constructor Create(aID : Integer);
     property ID : Integer read FID write FID;
  end;

  [TAttrTest2(1)]
  [TAttrTest2(2)]
  [TAttrTest2(3)]
  TMyObject = Class(TObject)
  end;

{ TAttrTest2 }

constructor TAttrTest2.Create(aID: Integer);
begin
 FID := aId;
end;

var
 c : TRttiContext;
 t : TRttiType;
 a : TCustomAttribute;
begin
   c := TRttiContext.Create;
   try
     t := c.GetType(TMyObject);
     for a in  t.GetAttributes do
     begin
       Writeln((a as TAttrTest2).ID);
     end;
   finally
     c.Free
   end;
   readln;
end.

Output:


1
2
3

Attributes also have a few other special items that the compiler implements.

If you have an attribute named like this...


type
TestAttribute = class(TCustomAttribute)
end;

It can be refered to in two different ways

[TestAttribute]
TExample = class(Tobject)
end;

[Test]
TExample2 = class(TObject)
end;

The compiler will look for the type, if it is not found it will automatically append "Attribute" to the name and search again. This is done to mimic the .NET behavior.

The compiler also has some special support for types allow you to get TRttiType
easily from the pTypeInfo pointer. The following code segment shows how that pTypeInfo can be interchanged for TRttitype in attributes.


uses
  SysUtils, Rtti;

type
  TestAttribute = class(TCustomAttribute)
  public
    constructor Create(aType : TRttiType);
  end;

  [Test(typeinfo(Integer))]
  TEmployee = class(TObject)
  end;

There are many practical applications for Attributes, I will explore many of these in later articles.

RTTI Article List

Delphi 2010 RTTI - The basics

2009-09-10T09:18:00.008-06:00

In Delphi 2009 and Prior RTTI was limited to items in the published section.
You had access to pointers for properties, fields and Methods on objects. If you spent some time learning, the old RTTI system was powerful. However, the power of the RTTI in prior versions seem very small when compared to what is now available in Delphi 2010.

In Delphi 2010 you have the option to have RTTI information for almost everything. The choice of what to include is yours, it is controlled by the new $RTTI directive. The default behavior is defined in System.pas shows that, properties and methods are now available via RTTI in both public and published sections, and Fields are available in all of the sections.


Section of System.pas:
{ RTTI Visibility }
type  
  TVisibilityClasses = set of (vcPrivate, vcProtected, vcPublic, vcPublished);

const
  { These constants represent the default settings built into the compiler.
    For classes, these settings are normally inherited from TObject. }
  DefaultMethodRttiVisibility = [vcPublic, vcPublished];
  DefaultFieldRttiVisibility = [vcPrivate..vcPublished];
  DefaultPropertyRttiVisibility = [vcPublic, vcPublished];

type
  { Default RTTI settings }
  {$RTTI INHERIT
      METHODS(DefaultMethodRttiVisibility)
      FIELDS(DefaultFieldRttiVisibility)
      PROPERTIES(DefaultPropertyRttiVisibility)}

Raw RTTI Information would be worthless unless you have good way to access the information. The new Unit RTTI.Pas provides a simple and elegant way to access this data. Flexibility of classes, with out the headaches of Memory Management was a key concern of the new design. As such RTTI access is done through a context, once that context is freed all the RTTI objects created are freed.


var
 c : TRttiContext;
begin
  c := TRttiContext.Create;
  try
     // RTTI Access code here
  finally
   c.free;
  end;
end;

If you open up RTTI.pas you will need notice that TRttiContext is not an object it is a Record, so don't get confused you should still call .Create and .Free as you would with an object. The reason for this is to free the pool of RTTI objects that may have been created. Atlhough the help file tells you not to free it, I personally like to clean up. Update:
I have had enough questions on this alone, I thought I would explain in more detail.

TRttiContext offers several key methods, which allow you to get access, to the types in the system.


    function GetType(ATypeInfo: Pointer): TRttiType; overload;
    function GetType(AClass: TClass): TRttiType; overload;
    function GetTypes: TArray<TRttiType>;
    function FindType(const AQualifiedName: string): TRttiType;

For example all of the following will return the TRttiType class representing, TButton.


var
  c : TRttiContext;
  t : TRttiType;
begin
  c := TRttiContext.Create;
  try
    // Via a String
    t := c.FindType('StdCtrls.TButton');

    // Via the pTypeInfo Pointer
    t := c.GetType(TButton.ClassInfo);

    // Via the class type
    t := c.GetType(TButton);
  finally
    c.Free;
   end;
end;

The TRttiType has many functions that allow you to query the members of that type.


    function GetMethods: TArray<TRttiMethod>; overload; virtual;
    function GetFields: TArray<TRttiField>; virtual;
    function GetProperties: TArray<TRttiProperty>; virtual;
    
    function GetMethod(const AName: string): TRttiMethod; virtual;
    function GetMethods(const AName: string): TArray<TRttiMethod>; overload; virtual;
    function GetField(const AName: string): TRttiField; virtual;
    function GetProperty(const AName: string): TRttiProperty; virtual;

So for example the following console application would show all of the methods of TButton.


program Project10;
{$APPTYPE CONSOLE}
uses
  StdCtrls, TypInfo, Rtti;

var
 c : TRttiContext;
 m : TRttiMethod;
begin
   c := TRttiContext.Create;
   for m in c.GetType(TButton).GetMethods do
   begin
     Writeln(m.ToString);
   end;
   c.Free;
   readln;
end.

Output:


constructor Create(AOwner: TComponent)
class destructor Destroy
procedure Click
... (Many Lines Removed) ...
procedure AfterConstruction
procedure BeforeDestruction
procedure Dispatch(var Message)
procedure DefaultHandler(var Message)
class function NewInstance: TObject
procedure FreeInstance
class destructor Destroy

Taking this to the next level the following code creates TStringList using the RTTI System, invokes the Add Method and accesses the Text Property. Granted this is not a practical example, it is just designed to show you some of the functionality available. You will notice that values are stored using the type TValue. TValue can store and retrieve any type.


program Project11;
{$APPTYPE CONSOLE}
uses
  StdCtrls, TypInfo, Classes, Rtti;

var
 c : TRttiContext;
 m : TRttiMethod;
 t : TRttiInstanceType;
 SL : TValue;
 Lines : TValue;
begin
   c := TRttiContext.Create;
   t := (c.FindType('Classes.TStringList') as TRttiInstanceType);
   SL := t.GetMethod('Create').Invoke(t.MetaclassType,[]);
   t.GetMethod('Add').Invoke(SL,['Hello Do you like my hat?']);
   t.GetMethod('Add').Invoke(SL,['I like that hat, what a party hat!']);
   Lines := t.GetProperty('Text').GetValue(SL.AsObject);
   Writeln(Lines.ToString);
   c.Free;
   readln;
end.

Output:


Hello Do you like my hat?
I like that hat, what a party hat!

Although it appears that TValue may act like a variant, TValue is not a replacement for Variant. Specifically, If you assign a specific type to a TValue you must retrieve it as that specific type. For example you can't assign an Integer to a TValue and retrieve it as a String, doing so results in an Invalid Type Cast.

This is just taste, future articles will cover this in more detail.

RTTI Article List

CodeRage IV - BDE to DBX

2009-09-09T15:54:00.003-06:00

Well I just finished my session on CodeRage IV Session BDE to DBX, and so I am reposting a messsage I posted at the end of DelphiLive with the same information.

My slides and code are available in SVN at my Google Code Site

The BDEtoDBXDataPump was a quick and dirty application but it should work, let
me know if you have a problem and I will update the code in SVN, I had to update it once since DelphiLiver version of this session.

The ComponentConverter will convert TQuery and TTable to TdbxQuery components.
It will also convert TDatabase to TSqlConnection, and few other things to help in the conversion, such as removing the BDE Units and adding in the DBX units.

The ComponentCoverter contains a few little gems such as a DFM Parser.

CodeRage Sessions

2009-09-01T14:43:00.009-06:00

Although, I just posted a fairly big teaser of my RTTI session, I neglected the other sessions I will be covering at CodeRage.

Building and Consuming Web Services in Delphi and Delphi Prism

Building Unit Tests with DUnit

Converting from BDE to DBX

Andreano Lanusse

various stops in Brazil

Practical Application of RTTI and Attributes

I hope to be able to chat with many of you next week at CodeRage.

Delphi 2010 - RTTI & Attributes

2009-09-01T14:28:00.022-06:00

So what is RTTI? RTTI is an acronym for Run Time Type Information. It allows you interact with the type system at Run Time. I like to compare RTTI to meta data information stored in a database. If I execute the following SQL statement "select * from employee" how does the database know what to return? How does the application know what will be returned? It all boils down to "MetaData Information" which allows you to look up what database fields and there associated types will be returned. With RTTI, you have this same access to types defined in your Delphi code.

Delphi has always had RTTI, but Delphi 2010 has taken RTTI to the next level.

CodeRage is next week, there are two session that will be covering the RTTI system in Delphi 2010.

The first is Barry Kelly's presentation on "Delphi Compiler RTTI Enhancements" if you have time to only see one, then see this one. Barry is the engineer behind the Compiler RTTI Enhancements. His presentation is currently scheduled for Tuesday.

The second, is mine on "Practical Application of RTTI and Attributes" my presentation is currently scheduled for Thursday.

Both are only 40 minutes long, it is enough to get your tips of your toes wet, and I want to jump right in :-)

As such I have prepared a series of blog posts, I will start posting these after my CodeRage Session. Most likely one each day. Although, I tend to hate teasers, I decided to post one :-P

Here is what to expect:

Delphi 2010 RTTI - The basics

Using Attributes and TCustomAttribute descendants

Exploring TRTTIType in depth

Introduction to TValue

Exploring TRttiMember Descendants in depth (Part I) Properties and Fields

Why I call TRttiContext.Create() and TRttiContext.Free()

Exploring TRttiMember Descendants in depth (Part II) Methods

TValue in Depth

INI persistence the RTTI way

Xml Serialization - Basic Usage

Xml Serialization - Control via Attributes

Attributes: Practical Example- Object to Client Dataset

Types by Package... Dynamic plug-in systems.

The above list may change a bit as I am still editing the material.

I will update this post with links to the blog posts, as the become available if you want to bookmark this page.

I hope to see you at CodeRage, to unleash the Chaos :-)

Wildfires - Santa Cruz Mountains

2009-08-14T08:24:00.002-06:00

Having lived next to mountain ranges in Utah all of my life I have witnessed the first hand the mighty power of a wild fire, more than once. This morning a news story caught my attention, there is a fire in the Santa Cruz, CA mountains, that just forced a Bonny Doon a town of 2000 to evacuate. I thought that was close to Scotts Valley, the home of Embarcadero Developer Tools (Codegear). A quick search of google maps, showed that Bonny Doon is just 15 miles away. Having seen wild fires go miles in just a matter of days, my thoughts and prayers are with you. I hope the employee's there families and friends are not impacted.

CodeRage sessions, ask your questions now.

2009-07-14T17:15:00.019-06:00

I have been working on my sessions for CodeRage. I have four sessions this time. I would like to solicit "pre-session" questions on three of my sessions. It's your chance to shape the material that is presented.

Do you have any questions on the topics below?
If so let me know via either a comment to this blog post or an email rlove at peakbiz.com

Converting from BDE to DBX
Learn how to convert your existing BDE applications to the DBX Architecture. We will cover the architectural and coding differences between BDE and DBX. We will then cover tools that freely available to assist you in this conversion.
Note: This session is similar to the material I presented at DelphiLive and by Andreano Lanusse in Brazil, so if you attended one of these sessions and have feedback, I would be glad to hear it.

Building and Consuming Web Services in Delphi and Delphi Prism
Walk step by step through the process to build and consume web services, with both Delphi Win32 and Prism.

Building Unit Tests with DUnit
Get up to speed with unit testing in DUnit. No prior knowledge of Unit testing or DUnit is required.
Note: If you have tried DUnit and did not understand it, I want to hear from you!

I need the questions by August 13th, as I need to record these sessions before I leave for a back-packing trip to the top of Mt. Whitney

BDE to DBX Data Pump - Small updates

2009-06-01T19:39:00.008-06:00

In the comments of BDE to DBX Blog Post I was made aware of three bugs in the BDEToDBXDataPump application.

I have fixed 2 of the 3 and made a blind attempt at the remaining one, since I can't reproduce.

The updates can be found in my googlecode SVN

The bug is most likely in an incorrect mapping here of currency fields. All of the mappings are done through a constant. See the code below, by my comments you can
tell how good I felt about it :-)


//Mapping Best Guess in 10 minutes of work, so I suspect there
//are problems but you could also change this to find tune for your
//specific mapping needs.
  FieldTypeMap : Array[TFieldType] of Integer =
   ( {ftUnknown} TDBXDataTypes.UnknownType, {ftString} TDBXDataTypes.AnsiStringType, {ftSmallint} TDBXDataTypes.Int16Type, {ftInteger} TDBXDataTypes.Int32Type, {ftWord} TDBXDataTypes.UInt16Type, // 0..4
    {ftBoolean} TDBXDataTypes.BooleanType, {ftFloat} TDBXDataTypes.DoubleType, {ftCurrency} TDBXDataTypes.BcdType, {ftBCD} TDBXDataTypes.BcdType, {ftDate}TDBXDataTypes.DateType , {ftTime} TDBXDataTypes.TimeType, {ftDateTime} TDBXDataTypes.DateTimeType, // 5..11
    {ftBytes}TDBXDataTypes.BytesType , {ftVarBytes} TDBXDataTypes.VarBytesType, {ftAutoInc} TDBXDataTypes.AutoIncSubType, {ftBlob} TDBXDataTypes.BlobType, {ftMemo} TDBXDataTypes.MemoSubType, {ftGraphic} TDBXDataTypes.BlobType, {ftFmtMemo} TDBXDataTypes.MemoSubType, // 12..18
    {ftParadoxOle}TDBXDataTypes.UnknownType , {ftDBaseOle}TDBXDataTypes.UnknownType, {ftTypedBinary}TDBXDataTypes.BlobType, {ftCursor}TDBXDataTypes.UnknownType, {ftFixedChar}TDBXDataTypes.CharArrayType, {ftWideString} TDBXDataTypes.WideStringType,  // 19..24
    {ftLargeint}TDBXDataTypes.Int64Type, {ftADT}TDBXDataTypes.AdtType , {ftArray}TDBXDataTypes.ArrayType , {ftReference}TDBXDataTypes.UnknownType, {ftDataSet}TDBXDataTypes.UnknownType, {ftOraBlob}TDBXDataTypes.BlobType, {ftOraClob} TDBXDataTypes.BlobType, // 25..31
    {ftVariant} TDBXDataTypes.UnknownType, {ftInterface}TDBXDataTypes.UnknownType, {ftIDispatch}TDBXDataTypes.UnknownType, {ftGuid}TDBXDataTypes.CharArrayType, {ftTimeStamp} TDBXDataTypes.DateTimeType, {ftFMTBcd} TDBXDataTypes.BcdType, // 32..37
    {ftFixedWideChar} TDBXDataTypes.WideStringType, {ftWideMemo} TDBXDataTypes.UnknownType, {ftOraTimeStamp} TDBXDataTypes.OracleTimeStampSubType, {ftOraInterval}TDBXDataTypes.OracleIntervalSubType, // 38..41
   {ftLongWord} TDBXDataTypes.Uint32Type, {ftShortint} TDBXDataTypes.Int16Type, {ftByte} TDBXDataTypes.Int8Type, {ftExtended} TDBXDataTypes.DoubleType, {ftConnection} TDBXDataTypes.UnknownType, {ftParams}TDBXDataTypes.UnknownType, {ftStream}TDBXDataTypes.UnknownType); //42..48

Hopefully my stab in the dark on the remaining issue of change ftCurrency to map to TDBXDatatypes.BCDType instead of CurrencyType is correct. I based it on the comments in dbxCommon.pas


      ///Delphi Currency data type in System unit.
      ///  Internally managed as a TDBXDataTypes.BCDType
      ///

      CurrencyType        = 25;

Anyway if anyone has any problems with BDEtoDBXDatapump please let me know by
posting an issue on Google Code that way I fix them. Please include the source and destination table/database types as it may be critical to figuring out the mapping problem.

Computer Language/Compiler Development

2009-05-29T14:43:00.005-06:00

In addition to everything else I have going on my life, I am a full time student.

I have to write a research paper on the basics of computer language development.

I am required to do a survey as part of this class.

If any of you would be so kind, would you please take my survey.

Update: Thank you for those that helped.

Delphi Live RTTI Session

2009-05-15T22:27:00.003-06:00

For those that attended my session, and any others who may ask.

The source code and the 3 slides from my RTTI session are on my SVN Repository.

DelphiLive Pictures

2009-05-15T12:09:00.004-06:00

I uploaded several raw pictures of DelphiLive. I will be uploading more to the same location later. Hopefully some from the What is cooking in the Labs session.

Slide Show below...

BDE to DBX

2009-05-14T18:59:00.003-06:00

Well I have finished my session on converting BDE to DBX.

My slides and code are available in SVN at my Google Code Site

The BDEtoDBXDataPump was a quick and dirty application but it should work, let
me know if you have a problem and I will update the code in SVN.

The ComponentConverter will convert TQuery and TTable to TdbxQuery components.
It will also convert TDatabase to TSqlConnection, and few other things to help in the conversion, such as removing the BDE Units and adding in the DBX units.

DelphiLive - Where is Delphi Going?

2009-05-14T14:02:00.021-06:00

Here is the disclaimer I have done my best to get my notes correct, but I may have missed something, slides go by sometimes too fast for those transcribed what is seen and heard.

Here are some of my raw notes from the first two sessions:

Four Delphi Projects going on at the same time.

Project Weaver

Main Themes

User Experience
Enhance Connectivity
Documentation

IDE usability
Team Productivity
Touch
IDE – Insight (easy Keyboard access to almost everything)
Improvements to DataSnap
Firebird Support
.NET AOP
SCM Support
Enhanced RTTI Support
Attribute Support
Seamless .NET <> Native communication
Windows 7 APIs and Direct 2D
Full Support of SOAP 1.2 Clients

Project X

Cross-platform Windows, Mac OS, and Linux
Cross-platform component library
DataSnap on all platforms

Project Chromium, Quality, Quality

Quality, Quality, Quality
Pascal Code Formatter
Documentation of the OTA
New Data binding model allowing binding to almost any property on a control
More integration with the database tools.

Project Commodore

64 Bit native
Full compiler, RTL and VCL support for 64 native
Multi-Core. Multi-threaded applications.

Sure it's not much more than a bullet point list... But several of the items are very intresting. The order is not defined... Other than Weaver is expected next.

I am sure more details will be coming from the Labs sessions.

We did see a really cool Touch Demo!

DelphiLive - Just getting started...

2009-05-13T12:46:00.006-06:00

Well I am now sitting in Multithreading Master Class with Marco Cantu and Cary Jensen.

At the break I will be switching and sitting in on the Delphi DataSnap 2009 Deep Dive. I have considered using the new Datasnap more than once. However, I have always ended up switching to something else. I have explored the source, written several demo apps, and feel like I understand it, I am really looking to see another perspective.

On the plane flight out, I was thinking about all of the questions I might be asked during my BDE to DBX session.

One of the questions I realized I could be asked was... How do I convert paradox and/or another BDE database to a DBX supported Database.

There are several options, but I don't feel like there is a really, really easy way to do this.

So hopefully I can finish before my session tomorrow a BDE to DBX DataPump application.... But no commitments :-)

Finalizing DelphiLive Material

2009-05-08T11:15:00.009-06:00

Well today I am putting the finishing touches on my DelphiLive presentations.

I will be presenting:

Power of the RTTI In Delphi
Moving from BDE to DBX

I have this love hate relationship with PowerPoint, sometimes I find its the best way to communication information. However as soon as things get technical I really dislike seeing a bunch of code on slides.

In My Power of the RTTI in Delphi Session I currently I have grand total of 3 Slides for this presentation the rest is code.

I will be covering:

Interacting with Published Information
Dynamic Method Invocation
Dynamic Class Creation
Ideas on how you might use it your applications.

In My BDE to DBX Session, I have several slides, but don't worry I have plenty of code and examples to show.

One of the things I like the best about this presentation won't come till near the end, but at the State of Utah we wrote a simple DFM parser and combined it with Martin Waldenburg Delphi Parser (TmwPasLex) and wrote a simple but effective conversion utility. It saved us tons of time when converting a BDE Application to DBX. The application we converted was not a simple demo program, It has 650+ DFMs. And several more units 500+ with no associated dfm. That does not count any third party code, or our own internally developed components.

I have updated the conversion utility to be slightly more generic as the original was specific to our needs. I will share that code with the attendees.

I hope to see you there!

How do you improve Quality?

2009-04-29T17:08:00.011-06:00

There typically are 3 types of projects, when it comes to quality that I have seen.

The focus is getting the code out the door and then you pick up the pieces.
The focus is on getting quality code out the door until deadline nears then you revert to number 1.
The focus is on getting quality code out the door and as deadline nears features may be dropped and the deadline may slip.

When the project starts everyone seems to be on board with the idea of #3 but typically I have seen it slip all the way to #1 quite quickly.

At my current employer we have an internal application that is used by 300+ end users.

We used to have:

ZERO people dedicated to QA. (4-5 Delphi Developers, 1 Mainframe Programmer, no analysts)
Testing was done by end users testing as they had time.
We had no automated or unit tests.
The build process was compile from your own machine and copy it the network, with any developer free to release any code they wanted. Which would sometimes step over the other developers uncommitted code.
We had two environment's

Development used by both developers and testing.
Production

Exceptions had no details or context to help track down problems.
We had a very small and painful bug tracking system.
We would commonly be related to #1 type model above.

Over the few years that I have been here we have made many changes.
We now have:

We now have three people dedicated to QA. ( 7 Delphi Developers, 1 Database PL/SQL developer, and 1 Analyst)
We have end users still testing with the time that they have. But we now have better management support to get additional time needed.
We have a few automated tests, and a few more unit tests, but we really could use many more.
Our build process runs every hour through Final Builder, alerting us with email when someone checks in bad code.
We now have 4 environment's

Development (Dedicated to Developers only)
TEST where users get first look
QA a final look before production usually with data refreshed from production
Production.

We now use the JCL Debug to help use find those Hard to Reproduce Errors.
We have a better bug tracking system, but still not nearly as nice as some of the home grown solutions I have used at past employers.
We are now some where between the #2 and #3 model's above.

Every release we ask what can we do better? We try to learn from our mistakes and implement solutions to prevent problems. We release a new version of our software nearly every month, so we are continually improving, and quality has improved in many ways in the past few years.

However, today I feel awful!

We put out a release on Friday morning last week. I don't think I have ever had a release go bad as this one has. Today we are still working on fixing major problems that were caused by the release.

Some of which would have been caught by better testing.
Some of which would have been caught by better management of the information coming in about problems. (i.e. it was reported but not acted on!) Since, I usually manage this information, it's the reason I feel awful.
Of course like all systems some of them would have taken an unreasonable amount of testing to find.

So I have been thinking, it's time to go back to and look at quality in new and different ways.

I have been making a list for a while that specific to our product on ways to improve quality. Several items on the list are general enough to share with others.

Build a health check system detects common/possible problems that can be run daily in each environment's, which is very database specific. We have scripts for all of these, but not an automated way to run them.

Tables without primary keys
Missing Synonyms
Invalid Synonyms
Tables without indexes
Missing Grants
Disabled Constraints in Oracle
Tables that have not been analyzed recently.
FK Constraints without index on child table (table level lock will be placed on the parent table if these are found)
Invalid Database Objects
Plus several that are specific to our schema, i.e. constraints that can't be described in meta data.

Error Messages (Exceptions)
- Ability to Send error messages to a web service
- Ability to capture a screen shot with the error message.
- Ability to ask users what they are doing when the exception occurred.
- Ability to attach reported errors to items in bug tracking system.
Code Review to help identify and build additional unit tests around the code.
Automated Performance Testing Benchmark system. (I think DUnit has something that will work for us)
Get current Delphi Unit tests into an daily build and smoke test instead of just being run by hand by developers.

Ok...

I have shared some of my ideas on how to improve quality, as well as some of the things we have done.

How have you improved Quality in the software you write?

I am open to any suggestions, this is just a small attempt to think out side of the box.

Since I just started this blog, I really hope that someone is reading this and has some good ideas they are willing to share.

Enhanced Screen Capture Code

2009-04-13T10:33:00.016-06:00

I had this crazy idea the other day. I want to see what my users screen looks like at the time an exception occurred. A quick Google search led me to this snippet of code on about.com.

After a bit of testing I found out that it only captures the main desktop or active window. Well since many of our users run with multiple monitors, it's possible our application is running on the second monitor. This means that if I capture the main desktop would potentially reveal nothing valuable.

So I rewrote the code to handle multiple monitors better.

So here is the interface section.


uses
  Windows, SysUtils, Graphics, MultiMon;

type
  EMonitorCaptureException = class(Exception);

  TCaptureContext = (ccActiveWindow,ccDesktopMonitor,ccActiveMonitor,
                     ccSpecificMonitor,ccAllMonitors);


function MonitorCount : Integer;

procedure CaptureScreen(aCaptureContext : TCaptureContext; destBitmap : TBitmap;aMonitorNum : Integer = 1);

procedure CaptureRect(aCaptureRect : TRect;destBitMap : TBitmap); inline;

procedure CaptureDeviceContext(SrcDC: HDC;aCaptureRect : TRect;destBitMap : TBitmap); inline;

The enumerated type TCaptureContext allows few different options.

ccActiveWindow: Capture an image of the ActiveWindow only.
ccDesktopMonitor: Capture an image of the primary/first monitor.
ccActiveMonitor: Capture an image of the monitor with the active window on it. If the active window is on more than one monitor it will pick the monitor that has the larger portion of the window on it. If the active window is not in the visible space of any monitor, it will pick the closest one.
ccSpecificMonitor: Capture an Image of a Specific Monitor specified by the aMonitorNum parameter. Note: aMonitorNum the first monitor is 1. You can use the MonitorCount function to determine the valid range of monitors. An EMonitorCaptureException will occur if you select a monitor number outside the valid range.
ccAllMonitors: Capture a single image of all the monitors.

The entire code for the unit can be downloaded from my SVN Repository.

To see it in Action...

File | New VCL Form Application.
Add SCapture.pas to the project, or place it in your library path
Drop down an Button and an Image on the Form
Place the following code in your button.


var
 b : TBitMap;
begin
 b := TBitmap.Create;
 try
    CaptureScreen(ccAllMonitors,B,1);
    Image1.Picture.Assign(b);
 finally
   b.FreeImage;
   b.Free;
 end;

There is also another routine that allows you to capture any Rect from the display.


var
 b : TBitMap;
 r : TRect;
begin
 b := TBitmap.Create;
 try
    r.top := 20;
    r.Left := 20;
    r.Bottom := 200;
    r.Right := 200;
    CaptureRect(R,B);
    Image1.Picture.Assign(b);
 finally
   b.FreeImage;
   b.Free;
 end;

Going back to the crazy idea of getting a screenshot on an exception. I have not implemented it yet, but something things to think about if you going to try.

EOutofMemory and EOutofResource Exceptions will most likely cause this code to fail, I would check the Exception class and if it's one of these don't take the screen shot.
Unhandled Exception's raised in the Exception Handler mask the original error. So if taking the screen shot fails, don't annoy the user.
Privacy & Security: The images of the desktop may contain information that may violate users privacy or be a security risk of image is not secured.
You want to capture the screen before the exception dialog appears otherwise the information you want will be masked by the dialog.

Regardless of my concerns, I will be coming up with a solution the positive outcome is greater than any potential negatives.

Finding the Hard to Reproduce Errors

2009-04-08T11:24:00.000-06:00

I used to do a ton of contract work. One of the most common reasons I was called out to a company was that their users were experiencing an exception, usually an access violation, which they could not reproduce in the development environment.

Since I have been fairly busy, and I really don't have time to do side work. I had a request to share what I do in this case, so they could go about fixing it with out me. Instead of just responding via email with my methods of madness, I decided to share the way I do this with everyone.

First off the only way your going to get information to help is with good logging. There are a variety of tools out there to help. But I have found a good old text file is typically the easiest method, although products like SmartInspect and CodeSite offer quite a bit more and may be worth investing in, I will let you evaluate and decide.

The problem with logging is that the information is only as good as what you supply. You don't know where the error is going to occur and you really don't need a log file endlessly filling up with useless information. So how do you know where to log? Well my favorite places to log information on Screen changes. That way I know the order of the screens visited, and sometimes key values that are needed for that screen. I also add verbose logging on a temporary basis for hard to find problems.

But hey! The odds are I have told you nothing that you did not know already.

I have found many people are not familiar with call stack logging when an exception occurs. In .NET getting the exception call stack is easy, you just need to reference the .StackTrace property on the exception. Once you have that write it out to your log file, using your method of choice.

However, with native code it requires quite a bit more work. This is because information about method names and line numbers are not part of the compiled code.
In Delphi the information that contains this information is in the MAP file. The key is how do you get this information at the time of the exception and log the details you need.

There are two commercial products out there that do just that and more.

I however use an open source alternative that works well. It's was also great when doing consulting as I did not have to make them buy a commercial product.

The Jedi Class Library (JCL) has the libraries needed to do this. It's used by Embarcadero inside of Delphi to report errors to Quality Central.

So take a moment if you have not already do it and download it now.

After installing the JCL, you will want to open and look at the following Demo applications found in the "jcl\examples\jclDebugExamples.bdsgroup" project group.
It offers a fairly good look at the possibilities.

Ultimately the question is: How do I plug the JCL Debug into my application and make it useful.

Here are simple steps to do this.

Download and Install JCL
Open "jcl\experts\debug\tools\MakeJclDbg.dpr" and Compile. It may have already been compiled during install.
Open: "jcl\experts\debug\dialog\CreateStdDialogs.dpr"
Look at "Params." around line 80 and set the params you want.
Run the application.
ExceptDlg.pas/dfm and ExceptDlgMail.pas/dfm will be generated
Copy these to your application source directory.
Add ExceptDlg to the uses of your project.
Turn on .MAP file generation in your project options. (Found under linker section)
Build your project.
At the command line run MakeJclDbg -E YourProjectName.MAP

You are good to go! Unhandled exceptions in your application will be replaced by this new dialog. Since the code to the dialog is in your source directory you can change it to meet your specific needs and/or design layout.

In the last few steps, I showed you my preferred method of dealing with information for symbols, but the JCL supports many other methods.

For example there is an expert that you can install that will do the same thing without dropping to the command prompt. Since I never deploy an application that is compiled in the IDE, I use FinalBuilder, calling MakeJclDbg seems second nature.

One of the key things is that symbols can be stored in a variety of different ways, and JCL will search for them in the following order.

JCL Debug data in the executable file (What MakeJclDbg and the Expert will do)
JDBG file
Borland TD32 symbols
MAP file
Library or Borland package exports

There is a good document on the options found in "\jcl\experts\debug\HowTo.txt"

Now the most surprising question that I have heard over and over after doing this is: What do I do with this information?

Well you now have a call stack when the exception occurred. You can see also see the line the exception occurred on. Often looking at the line of code where the error occurred shows that the given method was called incorrectly. With the call stack you can see the line of code that called that method. This typically this should give you enough of a clue to resolve the problem, or at the very least you will know where to add more logging to figure it out.

The Dark Side (of the moon) or Not?

2009-04-07T06:29:00.000-06:00

For the past couple of months we have been doing a fairly in depth review of Delphi Prism. We have a 6-8 month project that we need a fairly complex web service. Our past experience with Delphi for .NET and C# we knew that the API's in .NET would be a big advantage to our project.

Since we already own RAD Studio, it was time to review and see if Prism was the right technology or if we should just move back to Delphi Native only. The flip-flopping on the .NET side of Delphi has driven me crazy.

We decided to start with something simple but complex enough to test the needs of our project. If the technology did not prove it's self then we would not be out a ton of time.

The language changes took a few moments to get used to. Then after awhile you start wishing that Delphi Native had the features that are present in the Prism Compiler. I suspect that is partially why they are completely rewriting the Delphi Native Compiler.

The IDE in Prism is Visual Studio but I found the transition to the different IDE fairly easy, of course I have done quite a bit of C# work in the past.

Overall I have to say I am impressed. We have been able to build a solid web service in short time. The language being Pascal based is a huge win as it requires far less training that switching to entirely different language. I also liked several of the language features that C# does not have. Specifically Sets and the colon operator.

The one drawback I noticed was that there was not direct support for LINQ to SQL. If you have the full VS.NET product you can build a LINQ to SQL assembly and use it fine in Prism. However, Microsoft does not support Oracle which is the Database we use. Microsoft only supports SQL Server. If the DBX team could conquer LINQ to SQL for DBX it could be a huge win. But then again I think the designers only ship with the VS product and not with the Shell, which has been major reason for the flip-flopping of Delphi in the .NET world in the past.

Will we be using Prism for anything other than ASP.NET technologies? Well at this point I doubt it. I still am a huge fan of native code development. It does work well in the ASP.NET environment and we will be using it for our 6-8 Month project we were reviewing the technology for.

As for the title of the post? Look in the About box!

Blogging Again -or- Opening Mouth to Insert Foot

2009-04-06T17:58:00.000-06:00

Open Mouth Insert Foot. I feel like I do that enough... So why not start blogging again.

It's been several years since I last blogged. This time I am not going to try to develop and maintain a site for it. I just don't have the time to play around with duplicating technology that is already free and easy to use. Also, I don't have to worry about server costs and maintenance.

Well what has happened in the past few years since I quit blogging.

I started working at the State of Utah full-time, I used to do contract work there. It was the right move for my family and in total I have spent 6+ years there. The State of Utah currently pays for tuition so I am enrolled in school. The school is WGU, it's an online only school. I feel I might as well get that degree sooner or later, and I enjoy research and learning.

I am still doing the following:

Develop in Delphi although now I have to manage a team of nine.
President of the Salt Lake City Delphi Users Group.
Finding other ways to open my mouth and insert my foot.

Cooking outdoors as much as possible.