There are several ways of setting an arbitrary format:

• Declarative definition of format for data objects. Format is declared via FormatAttribute for data object properties. If data of different types is used in the grid, this approach enables different ways of formatting values in the same column. Besides, when the same data objects are used in different grids, they are displayed in the same way in the entire application.
  
  

  
  

  class Quote
  {
      ...
  
      [Format(typeof(CustomFormat))]
      public double Price
      {
          get { return _price; }
      }
  
      ...
  }

  
  
  There are some specialized attributes that simplify declarative format definition: DoubleFormatAttribute, EmptyFormatAttribute etc.  It is also possible to create custom attributes for declaring formats with parameters.
  
  

  //Display a number using specific format string
  class CustomFormat : IFormat
  {
      private readonly string _formatString;
  
      public CustomFormat(string formatString)
      {
          _formatString = formatString;
      }
  
      public string Format(IDataField dataField)
      {
          return string.Format(CultureInfo.InvariantCulture, "{0:" + _formatString +"}", dataField.Value).Trim();
      }
  
      public bool CanParse(string text, IDataField dataField)
      {
          return false;
      }
  
      public void Parse(string text, IDataField dataField)
      {
      }
  }
  
  //An attribure returning an instance of IFormat object
  public class CustomFormatAttribute : FormatBaseAttribute
  {
      private readonly string _formatString;
  
      public CustomFormatAttribute(string formatString)
      {
          _formatString = formatString;
      }
  
      public override IFormat Format
      {
          get { return new CustomFormat(_formatString); }
      }
  }
  
  //Declare custom format
  class Quote
  {
      ...
  
      [CustomFormat("### ### ##0.##")]
      public double Price
      {
          get { return _price; }
      }
  
      ...
  }

• Format can be set directly in grid column and values in cells will be formatted in the same way disregarding formats set via FormatAttribute

  
  

  Column column = grid.Headers[0]["Price"];
  column.Format = new CustomFormat("### ### ##0.##");

Values can be transformed to text strings displayed in the grid as follows:

• The grid checks whether format is set for column corresponding to cells.

• If no format is found, the grid checks whether declarative format exists for data object field.

• If neither format is found, the grid searches for default format corresponding to data type. Basically this format calls object.ToString() method or invokes the ConvertTo() of appropriate TypeConverter.

• The string is written to PaintCellEventArgs where the programmer can easily modify it:
  
  

  
  

  grid.PaintCell += delegate(object sender, PaintCellEventArgs e)
  {
      if(e.Cell.Column != null && e.Cell.Column.Id == "some id")
      {
          e.Text = "a new text to be displayed in cell";
      }
  };

• Finally, the resulting string is displayed in grid cell via Graphics object.

Formats can be two-sided. It means that data entered by user in cell editors can be transformed from text to unformatted values and transmitted to data objects. For this purpose it is sufficient to implement CanParse and Parse methods in a class implementing IFormat.

class CustomFormat : IFormat
{
    public string Format(IDataField dataField)
    {
        return string.Format(CultureInfo.InvariantCulture, "{0:### ### ##0.##}", dataField.Value).Trim();
    }

    public bool CanParse(string text, IDataField dataField)
    {
        text = text.Replace(" ", string.Empty);
        double value;
        return double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out value);
    }

    public void Parse(string text, IDataField dataField)
    {
        text = text.Replace(" ", string.Empty);
        dataField.Value = double.Parse(text, NumberStyles.Float, CultureInfo.InvariantCulture);
    }
}

An actual project may consist of multiple assemblies some of which may represent application business logic while others may represent graphical controls displaying this logic. To comply with the principle of business logic being independent from presentation, in such case it would be good to remove dependency on assemblies with graphical components in business logic assemblies, including Dapfor.Net.dll assembly.

On the other hand, sometimes it would be convenient to use declarative data formatting set with FormatAttribute attributes.

Microsoft component model can be used to avoid adding dependency on Dapfor.Net.dll to application business logic. Specifically, it would be good to use TypeConverter that enables transformation of data of one type to another and back. In most cases these converters are set for data types:

TypeConverter converter = TypeDescriptor.GetConverter(typeof (Color));

//Type converter to transform double values to strings and vice versa
class DoubleTypeConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
    }

    //Converts value to string
    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
    {
        if (destinationType == typeof(string))
        {
            return string.Format(CultureInfo.InvariantCulture, "{0:### ### ##0.##}", value).Trim();
        }

        return base.ConvertTo(context, culture, value, destinationType);
    }

    //Converts string to double value
    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
    {
        if (value is string)
        {
            string text = ((string)value).Replace(" ", string.Empty);
            double v = 0;
            if(!string.IsNullOrEmpty(text))
            {
                double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out v);
            }
            return v;
        }

        return base.ConvertFrom(context, culture, value);
    }
}

//Declaration of the converter without reference to the Dapfor.Net.dll assembly
class Quote
{
    ...

    [TypeConverter(typeof(DoubleTypeConverter))]
    public double Price
    {
        get { return _price; }
        set { _price = value; }
    }

    ...
}