Intro

Sometimes you create a new type and need to redefine certain operators in order to make your life easier. For instance, matrix or complex numbers operations. It’s way more comfortable (and understandable) to write a simple plus symbol than calling a method to perform an addition.

It’s pretty straightforward: you define a static method with the keyword operator such as this:

[sourcecode language='csharp']

//Complex addition
public static Complex operator +(Complex a, Complex b)
{
a.Re = a.Re + b.Re;
a.Im = a.Im + b.Im;
return a;
}
[/sourcecode]

And then you just forget about that and simply use it! So… why not also forget about type conversion?

Your custom type conversion

In certain cases you need to create a constructor that receives an object and “converts” it to another, or a method to change it backwards.

Supose you have Rectangular and Polar types. You could have the following code to perform the conversion between each of them:

[sourcecode language='csharp']

//Rectangular type
public Rectangular(Polar polar)
{
X = polar.R * Math.Cos(polar.Theta);
Y = polar.R * Math.Sin(polar.Theta);
}

public Polar ToPolar()
{
Polar polar = new Polar();
polar.R = Math.Sqrt(X * X + Y * Y);
polar.Theta = Math.Atan2(X, Y);
return polar;
}

//Polar Type
public Polar(Rectangular rectangular)
{
R = Math.Sqrt(rectangular.X * rectangular.X + rectangular.Y * rectangular.Y);
Theta = Math.Atan2(rectangular.X, rectangular.Y);
}

public Rectangular ToRectangular()
{
Rectangular rectangular = new Rectangular();
rectangular.X = R * Math.Cos(Theta);
rectangular.Y = R * Math.Sin(Theta);
return rectangular;
}

//Usage example
Rectangular r = new Rectangular(3,1);
Polar p = new Polar(r);
Polar p2 = r.ToPolar();
Rectangular r2 = new Rectangular(p);

[/sourcecode]

Instead of that, you could define your own type conversion as follows:

[sourcecode language='csharp']

//Polar type
public static explicit operator Polar (Rectangular r) {
Polar p;
p.R = Math.Sqrt(r.X * r.X + r.Y * r.Y);
p.Theta = Math.Atan2(r.X, r.Y);
return p;
}

//Rectangular type
public static explicit operator Rectangular (Polar p) {
Rectangular r= new Rectangular();
r.X = p.R * Math.Cos(p.Theta);
r.Y = p.R * Math.Sin(p.Theta);
return r;
}

[/sourcecode]

And then use it like usual

[sourcecode language='csharp']

Rectangular r = new Rectangular(3,2);
Polar p = (Polar)r;

[/sourcecode]

A word on method declaration

The method declared must be static for conversion to work without creating an instance of target type first. It should also be visible in other scopes, so it should be public or at least internal.

The explicit operator expression shows that the conversion must be explicit. You could also define it as implicit, in which case the assignment in our example would only be Polar p = r; I personally dislike this option since it can lead to unwanted results.

The name of the method must be the name of the target type of conversion.

The parameter is the instance to be converted.

References

Casting

Explicit Keyword

Implicit Keyword

They work great when they are part of the startup project but – there’s always a but that ends up in a post – when you use them on a referenced project they always take their default value.

After three days of poring over blogs, framework documentation and other resources I concluded that no solution or work-around was readily available, even though the problem seems to be well known.

I tried several approaches, this post will describe the one I consider the best. You can skip the discussion and download the code directly here or keep on reading to find out how it’s done and download it later.

Scenario

I stumbled on this problem while testing the new “multi-function terminal” for the Dot Baires Shopping. The application is deployed in many terminals which communicate with external services providing their identity, for example ‘abc123′, also each machine has its own timeout parameters, for example time to go back to the home screen. These parameters may vary from one machine to the next.

“Hardcoding” the values was obviously not an option, the sole idea of one compilation per station was disturbing. I could, of course, have written a parser and stored these values in an XML, but I already had the Settings feature provided by the framework and I wanted to use it.

How Settings Work

When you add a “Settings” to a project, (I will name it “MySettings” in these example), Visual Studio automatically adds an app.config file, it also keeps synchronized the MySettings.settings file with MySettings.Designer.cs and the app.config, as you can see the default value of the setting is stored in three places.

When the project is compiled a file named ProjectName.exe/dll.config is generated, the .exe.config file has no mystery, you have compiled a solution and the settings are used in the startup project, change this file and you will see the changes in the application.

Settings in a DLL

Well, settings were beautiful so far, but here they get a little tricky – a nice word for buggy.

Let’s imagine you are building a solution that has a Persister, a Credit Card Manager and UI interaction, you want to reuse your Credit Card code in other projects so you put it in a project of its own with its own configuration values in the Settings, probably a Store Id for the transactions and other things . Now you compile the Credit Card project…, great!! the compiler generated a CreditCard.dll.config file which holds the Store Id as we expected!

Well, let’s compile the solution then! Mmm…, but where is the CreditCard.dll.config now??, to make a long story short it’s not there, there is one in the CreditCard project folder bindebug, but if you copy it to the directory the solution was build into you will find out the values will still be the default no matter what you do. The reason is the .config files are only used in the startup project.

My approach

After three days reading I couldn’t find a solution I liked.

I like Settings, they provide a good way to save data in files without having to write a parser, also the data are strongly typed and have default values in case the .config is not found.

After all the Settings are a main gear in the .Net Framework, so I started thinking of a work-around.

My approach was simple, if the .dll.config file wasn’t being read I had to add a file of my own, so I thought of the configSource attribute that can be applied to the userSettings, if you want to read more go to http://aspalliance.com/820.

Test solution

Components of the solution

1. Winform project “Test” with a form “TestForm”
2. Dll project “DllWithSettings” with Settings “MySettings.settings”
3. I added a class “SettingsConsumerClass” in the “DllWithSettings” project to access settings dependent values from the winform project “Test”

TestForm.cs

[sourcecode language='csharp']
using System.Windows.Forms;

namespace Test
{
public partial class TestForm : Form
{
public TestForm()
{
InitializeComponent();
MessageBox.Show(“String Value: ” + DllWithSettings.SettingsConsumerClass.StringValue + “nInt Value: ” + DllWithSettings.SettingsConsumerClass.IntValue);
Focus();
}
}
}
[/sourcecode]
SettingsConsumerClass.cs
[sourcecode language='csharp']
namespace DllWithSettings
{
public static class SettingsConsumerClass
{
private static readonly int _intValue = MySettings.Default.TestValue;
private static readonly string _stringValue = MySettings.Default.AnotherTestValue;

public static int IntValue
{
get
{
return _intValue;
}
}

public static string StringValue
{
get
{
return _stringValue;
}
}
}
}
[/sourcecode]

If you try what we have written so far you’ll see that it compiles, and it also shows the settings, but if you look for the output directory you will see there’s no .config file and if you copy the one generated in the “DllWithSettings” output directory and change it nothing will happen.

Making it work

First I extracted the settings from the app.config and put them in DllWithSettings.config, this means changing the app.config in the “DllWithSettings” project from

[sourcecode language='csharp']

123

Compiled

[/sourcecode]

to

[sourcecode language='csharp']

[/sourcecode]

DllWithSettings.config
[sourcecode language='csharp']

123

Compiled
[/sourcecode]

The “Copy to output directory” of this file must be set to “Copy if newer” so it’s available at runtime.

The second and last thing to do is to reference this file in the app.config of the startup project too – if you don’t have an app.config add one.

Because the settings defined in the app.config of the startup project always override others, referencing MySettings.config and making this settings belong to the correct namespace overrides the defaults of “DllWithSettings”, allowing to change them without recompiling.

The app.config in “Test” changes from

[sourcecode language='csharp']

[/sourcecode]

to

[sourcecode language='csharp']

[/sourcecode]

You can download the source code here.

Well, that’s all, hope you learned something useful, please post if you have any doubts or comments!

If you ever had to deal with legacy apps, you must have come across data stored in DBF files; and  if you are  like me, you find it frustrating  that support for  DBFs will depend on factors such as which service packs are installed wherever it is your program must run – and this is often out of your  control, since the “old” system must remain  operative, at least until you migrate the data…or maybe you have to exchange data with such an app on a regular basis, since your client only wants to move part of his business to a new platform.

After one too many such frustrations, I decided to write a small utility that would kill this problem for me once and for all – well, at least as far as clients using VB6 go. No rocket science, but it gets the job done, and I can forget about dll-activex-SP swamps and concentrate on doing my job.

Even though I wrote this for myself, the code is pretty clear (I was planning on reusing it, and I did), so you  can simply download it from here, add it to your VB6 project as an existing module and you’re ready to go.

DBF files  – a brief note on an old technology

A DBF file is essentially a self-contained database table, complete with both field definitions and data.

Each field definition is persisted in a structure (type dbfFieldDef in the code) where the main features are field name, type (I only consider Character (string), Numeric, Date and Logical (Boolean)), size, and number of decimals. Most other properties, interesting though they may be, are not used in my code and if you don’t plan on changing it you may basically ignore them.

As opposed to modern relational databases, DBFS have a “record number” property (that may change if you delete and expunge some other  record), which is simply a pointer to the physical position of the record in the table.

There is also a global header that takes up the first 32 bytes in the file (type dbfHeader).  Field cIsDbf must be 0×03 if we are talking about a DBF 3 file, the kind used by CA-Clipper.  ymlLUpdate  holds the date the file was last updated. The rest of the fields are both useful (e.g.to compute the fieldCount property when you open a new file) and self-explanatory. Note that lRecCount is actually redundant, you could compute it from iHeaderSize , iRecordSize and the physical file size…(or you could figure one of the other parameters reading lRecCount), so you can easily “fix” a DBF file if the record count is lost – I saw this happen quite a few times.

So what does this code do?

As you would expect it lets you:

Open and close the DBF
Public Function dbfOpen(ByVal fn As String, mgr As dbfmanager) As Integer
Public Function dbfClose(mgr As dbfmanager) As Integer

Move around the table (when you ‘go’ to a record, you also read it and
you can get its field using dbField())
Public Function dbGoTo(i As Integer) As Integer  ‘Go to record nr I
Public Function dbGoTop() As Integer             ‘Go to 1st record
Public Function dbfMoveFirst()                   ‘actually an alias for dbGoTop()
Public Function dbfMoveNext()                    ‘move to next record, (test EOF)
Public Function dbGoBottom() As Integer          ‘go to last record

Write data
Public Function dbAppendBlank() As Integer ‘append a blank record at the bottom,
‘it becomes the current record
Public Function dbReplace(ByVal fieldName As String, v As Variant) As Integer
‘set field value for current record
‘the record will not be written until you commit()
Public Function dbCommit() As Integer      ‘write changes to disk

Read  data
Property Get dbField(ByVal fieldName As String) As Variant  ‘read a field (column) value
Property Get EOF() As Boolean
Property Get MyBookmark() As Integer                        ‘bookmark a record
Property Let MyBookmark(i As Integer)                       ‘go to bookmarked record

Utility funcions
Function ZFormat(nNro, nIntegers, nDecimals)                ‘I find this formatting function more user friendly than VBs strings
Public Function stripnulls(ByVal s As String) As String     ‘deal with c like null terminators

A note on implementation

The code includes a 2nd class module ‘dbfmanager.cls’  – The idea is that you may want to manage a collection of dbfs as a single object, so I provided this class to do things like closing a bunch of dbf’s in a single command, etc. I never got around to doing it…