[Serializable]
public class Reference : Record, IConvertibleTo<ReferenceCondition>
{
    protected string code;
    protected string name;
    private Reference parent;
    private ReferenceType type;

    public Reference()
        : this(ReferenceType.Unknown)
    {
    }

    public Reference(ReferenceType type)
    {
        this.type = type;
    }

    [XmlAttribute, DefaultValue(null)]
    public virtual string Code
    {
        get { return code; }
        set { code = value; }
    }

    [XmlAttribute, DefaultValue(null)]
    public virtual string Name
    {
        get { return name; }
        set { name = value; }
    }

    [XmlElement]
    public virtual Reference Parent
    {
        get { return parent; }
        set { parent = value; }
    }

    [XmlIgnore, DefaultValue(ReferenceType.Unknown)]
    public virtual ReferenceType Type
    {
        get { return type; }
        set { type = value; }
    }

    public override void Clear()
    {
        base.Clear();

        code = null;
        name = null;
        parent = null;
    }

    public override bool IsEmpty()
    {
        return base.IsEmpty()
            && String.IsNullOrEmpty(code)
            && String.IsNullOrEmpty(name);
    }

    protected override void ToEmpty()
    {
        base.ToEmpty();

        parent = new Reference();
    }

    public override string ToString()
    {
        if (!String.IsNullOrEmpty(name))
            return name;
        if (!String.IsNullOrEmpty(code))
            return code;
        return String.Empty;
    }

    public static bool CodeIsEmpty(Reference item)
    {
        return (item == null || String.IsNullOrEmpty(item.Code));
    }

    public static bool NameIsEmpty(Reference item)
    {
        return (item == null || String.IsNullOrEmpty(item.Name));
    }

    // Реализация интерфейса IConvertibleTo<ReferenceCondition>
    public virtual void CopyTo(ReferenceCondition item)
    {
        base.CopyTo(item);

        item.Code = code;
        item.Name = name;
        item.Parent = ConvertTo<ReferenceCondition>(parent);
        item.Type = type;
    }
}

[Serializable]
public class NearbyPlace : Reference, IConvertibleTo<NearbyPlaceCondition>
{
    private float distance;

    /// <summary>
    /// Растояние до места
    /// </summary>
    [XmlAttribute, DefaultValue(0)]
    public float Distance
    {
        get { return distance; }
        set { distance = value; }
    }

    public override void Clear()
    {
        base.Clear();

        distance = 0f;
    }

    public override string ToString()
    {
        if (distance > 0f)
            return String.Format("{0} - {1:f2} km", base.ToString(), distance);
        return base.ToString();
    }

    // Реализация интерфейса IConvertibleTo<NearbyPlaceCondition>
    public void CopyTo(NearbyPlaceCondition item)
    {
        base.CopyTo(item);

        if (distance > 0f)
            item.MaxDistance = distance;
    }
}