You are here: Advanced Features > Type Handling > Static Fields And Enums > Storing Static Fields

Storing Static Fields

By default db4o does not persist static fields. This is not necessary because static values are set for a class, not for an object. However you can set up db4o to store static fields if you want to implement constants or enumeration: See "Persist Static Fields"

IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
configuration.Common.ObjectClass(typeof (Person)).PersistStaticFieldValues();
ObjectConfigurationExamples.cs: Persist also the static fields
Dim configuration As IEmbeddedConfiguration = Db4oEmbedded.NewConfiguration()
configuration.Common.ObjectClass(GetType(Person)).PersistStaticFieldValues()
ObjectConfigurationExamples.vb: Persist also the static fields

When this setting is enabled, all non-primitive-typed static fields are stored the first time an instance of the class is stored. The values are restored every time a database file is opened afterwards, after the class meta information is loaded for this class (when the class objects are retrieved with a query, for example).

Use this option with caution. This option means that static fields are stored in the database. When you change the value of this field, you need to store it explicitly again. Furthermore, db4o will replace the static value at runtime, which can lead to very subtle bugs in your application.

This option does not have any effect on primitive types like ints, longs, floats etc.

Enum Class Use case

One of the use-cases is when you have an enumeration-class which you want to store. For example we have a color-class, which also has some static colors.

public sealed class Color
{
    public static readonly Color Black = new Color(0, 0, 0);
    public static readonly Color White = new Color(255, 255, 255);
    public static readonly Color Red = new Color(255, 0, 0);
    public static readonly Color Green = new Color(0, 255, 0);
    public static readonly Color Blue = new Color(0, 0, 255);

    private readonly int red;
    private readonly int green;
    private readonly int blue;

    private Color(int red, int green, int blue)
    {
        this.red = red;
        this.green = green;
        this.blue = blue;
    }

    public int RedValue
    {
        get { return red; }
    }

    public int GreenValue
    {
        get { return green; }
    }

    public int BlueValue
    {
        get { return blue; }
    }

    public bool Equals(Color other)
    {
        if (ReferenceEquals(null, other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return other.red == red && other.green == green && other.blue == blue;
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;
        if (obj.GetType() != typeof (Color)) return false;
        return Equals((Color) obj);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            int result = red;
            result = (result*397) ^ green;
            result = (result*397) ^ blue;
            return result;
        }
    }

    public override string ToString()
    {
        return string.Format("Red: {0}, Green: {1}, Blue: {2}", red, green, blue);
    }
}
Color.cs: Class as enumeration
Public NotInheritable Class Color
    Public Shared ReadOnly Black As New Color(0, 0, 0)
    Public Shared ReadOnly White As New Color(255, 255, 255)
    Public Shared ReadOnly Red As New Color(255, 0, 0)
    Public Shared ReadOnly Green As New Color(0, 255, 0)
    Public Shared ReadOnly Blue As New Color(0, 0, 255)

    Private ReadOnly m_red As Integer
    Private ReadOnly m_green As Integer
    Private ReadOnly m_blue As Integer

    Private Sub New(ByVal red As Integer, ByVal green As Integer, ByVal blue As Integer)
        Me.m_red = red
        Me.m_green = green
        Me.m_blue = blue
    End Sub

    Public ReadOnly Property RedValue() As Integer
        Get
            Return m_red
        End Get
    End Property

    Public ReadOnly Property GreenValue() As Integer
        Get
            Return m_green
        End Get
    End Property

    Public ReadOnly Property BlueValue() As Integer
        Get
            Return m_blue
        End Get
    End Property

    Public Overloads Function Equals(ByVal other As Color) As Boolean
        If ReferenceEquals(Nothing, other) Then Return False
        If ReferenceEquals(Me, other) Then Return True
        Return other.m_red = m_red AndAlso other.m_green = m_green AndAlso other.m_blue = m_blue

    End Function

    Public Overloads Overrides Function Equals(ByVal obj As Object) As Boolean
        If ReferenceEquals(Nothing, obj) Then Return False
        If ReferenceEquals(Me, obj) Then Return True
        If Not Equals(obj.GetType(), GetType(Color)) Then Return False
        Return Equals(DirectCast(obj, Color))

    End Function

    Public Overrides Function GetHashCode() As Integer
        Dim hashCode As Integer = m_red
        hashCode = (hashCode * 397) Xor m_green
        hashCode = (hashCode * 397) Xor m_blue
        Return hashCode
    End Function

    Public Overrides Function ToString() As String
        Return String.Format("Red: {0}, Green: {1}, Blue: {2}", m_red, m_green, m_blue)
    End Function
End Class
Color.vb: Class as enumeration

We want to ensure reference equality on colors so that you easily can check for a certain color. But when we load the colors from the database you get new instances and not the same instance as in the static field. This means that comparing the references will fail.

// When you enable persist static field values, you can compare by reference
// because db4o stores the static field
if (car.Color == Color.Black)
{
    Console.WriteLine("Black cars are boring");
}
else if (car.Color == Color.Red)
{
    Console.WriteLine("Fire engine?");
}
StoringStaticFields.cs: Compare by reference
' When you enable persist static field values, you can compare by reference
' because db4o stores the static field
If car.Color Is Color.Black Then
    Console.WriteLine("Black cars are boring")
ElseIf car.Color Is Color.Red Then
    Console.WriteLine("Fire engine?")
StoringStaticFields.vb: Compare by reference

When you enable the persist static fields option, the static fields are stored. This means that the object referenced in the static fields are loaded from the database and therefore the same instance. And the comparing the references works again.

IEmbeddedConfiguration configuration = Db4oEmbedded.NewConfiguration();
configuration.Common.ObjectClass(typeof (Color)).PersistStaticFieldValues();
StoringStaticFields.cs: Enable storing static fields for our color class
Dim configuration As IEmbeddedConfiguration = Db4oEmbedded.NewConfiguration()
configuration.Common.ObjectClass(GetType(Color)).PersistStaticFieldValues()
StoringStaticFields.vb: Enable storing static fields for our color class