2 people like it.

DataGridView BindingSource Sorting and Filtering

The code snippet for working with Windows Forms DatagridView with filtering and sorting features.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48: 
49: 
50: 
51: 
52: 
53: 
54: 
55: 
56: 
57: 
58: 
59: 
60: 
61: 
62: 
63: 
64: 
65: 
66: 
67: 
68: 
69: 
70: 
71: 
72: 
73: 
74: 
75: 
76: 
77: 
78: 

open System
open System.Data
open System.Windows.Forms
open System.ComponentModel
open System.Collections.Generic
open System.Drawing
open System.Text

[<AutoOpen>]
module Globals =
  let rnd = System.Random(System.DateTime.Now.Millisecond)

type Item(id:int, name:string, surname:string,preference:string) =
    member this.Id = id
    member this.Name = name
    member this.Surname = surname
    member this.Preference = preference

let getNewRecord(rnd:Random,id:int) =
         let names = ["John";"James";"Robert";"William";"Michael";"Anthony";"Richard";"Thomas";"Charles";"Gary";"Andrew";"Oliver";"Alexander";"Christopher";"Adrian";]
         let surnames = ["Smith";"Jones";"Taylor";"Williams";"Wilson";"Johnson";"Davies";"Robinson";"Wright";"Thompson";"Evans";"Walker";"Roberts";"Hall";"Wood";"Jackson";"Clark";"Browning";
         "Mossberg";"Wahlberg";"Murphy";"Collins";"O'Donnell";"Sheridan";"Griffith";"Higgins";"Foster"]
         let prefs = ["Apple";"Banana";"Strawberries";"Grapes";"Blueberries";"Clementines";"Raspberries";"Orange";"Pear";"Lemons";]
         let curName = names.[rnd.Next((names.Length))] 
         let curSurname = surnames.[rnd.Next((surnames.Length))] 
         let curPref = prefs.[rnd.Next((prefs.Length))]           
         let myItem = new Item(id, curName,curSurname,curPref)
         myItem

let  formM  =  new  Form()
formM.Size <- new Size(600,400)
let  input  =  new  TextBox()
let  bindingSource = new BindingSource()
let  button  =  new  Button(Left  =  input.Right  +  10,  Text  =  "Go")
 
let  output:System.Windows.Forms.DataGridView  =  new  DataGridView(Top  =  input.Bottom  +  10, Width  =  (formM.Width-10),  Height  =  (formM.Height  -  (input.Bottom  +  40)), Anchor  =  (AnchorStyles.Top  |||  AnchorStyles.Left  |||  AnchorStyles.Right  |||  AnchorStyles.Bottom))
output.ScrollBars = ScrollBars.Both  |> ignore
output.RowsDefaultCellStyle.BackColor <- Color.FromArgb(141, 178, 85)
output.AlternatingRowsDefaultCellStyle.BackColor <- Color.Beige  

let convertToDataTable(data: List<'T>)=
   let properties = TypeDescriptor.GetProperties(typedefof<'T>)
   let table = new DataTable()
   for prop:PropertyDescriptor in properties do
    table.Columns.Add(prop.Name,  prop.PropertyType) |> ignore 
   for  item:'T in data do
      let row = table.NewRow()
      for prop:PropertyDescriptor in properties do
          row.[prop.Name] <- prop.GetValue(item)
      table.Rows.Add(row)
   table

button.Click.Add(fun  _  ->  
    let myList = new List<Item>()    
    let peoplesList = [for number in [1..100] -> getNewRecord(rnd,number)  ] 
    peoplesList |> List.iter(fun c-> myList.Add(c))
    let dt:DataTable = convertToDataTable(myList)    
    bindingSource.DataSource <- dt
    output.DataSource <- (bindingSource :>(Object) )   
    ())

let  dc  c  =  c  :>  Control
formM.Controls.AddRange([|dc  input;  dc  button;  dc  output  |])

let onInpTextChanged(sender:Object,e:EventArgs):unit=
   let bd:BindingSource = output.DataSource :?> BindingSource
   let dt:DataTable = bd.DataSource :?> DataTable
   let str = String.Format("Name like '{0}%' OR Surname like '{0}%' OR Preference like '{0}%' ", input.Text.Trim().Replace("'", "''"))
   dt.DefaultView.RowFilter <- str
   output.Refresh()
   ()

input.TextChanged.AddHandler(new System.EventHandler(fun s e -> onInpTextChanged(s, e))) 

formM.ShowDialog() |> ignore 

[<STAThread()>]
Application.Run()
namespace System
namespace System.Data
namespace System.Windows
namespace System.ComponentModel
namespace System.Collections
namespace System.Collections.Generic
namespace System.Drawing
namespace System.Text
Multiple items
type AutoOpenAttribute =
  inherit Attribute
  new : unit -> AutoOpenAttribute
  new : path:string -> AutoOpenAttribute
  member Path : string

--------------------
new : unit -> AutoOpenAttribute
new : path:string -> AutoOpenAttribute
val rnd : Random
Multiple items
type Random =
  new : unit -> Random + 1 overload
  member Next : unit -> int + 2 overloads
  member NextBytes : buffer:byte[] -> unit + 1 overload
  member NextDouble : unit -> float

--------------------
Random() : Random
Random(Seed: int) : Random
Multiple items
type DateTime =
  struct
    new : ticks:int64 -> DateTime + 10 overloads
    member Add : value:TimeSpan -> DateTime
    member AddDays : value:float -> DateTime
    member AddHours : value:float -> DateTime
    member AddMilliseconds : value:float -> DateTime
    member AddMinutes : value:float -> DateTime
    member AddMonths : months:int -> DateTime
    member AddSeconds : value:float -> DateTime
    member AddTicks : value:int64 -> DateTime
    member AddYears : value:int -> DateTime
    ...
  end

--------------------
DateTime ()
   (+0 other overloads)
DateTime(ticks: int64) : DateTime
   (+0 other overloads)
DateTime(ticks: int64, kind: DateTimeKind) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, calendar: Globalization.Calendar) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: DateTimeKind) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: Globalization.Calendar) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int, kind: DateTimeKind) : DateTime
   (+0 other overloads)
property DateTime.Now: DateTime with get
Multiple items
type Item =
  new : id:int * name:string * surname:string * preference:string -> Item
  member Id : int
  member Name : string
  member Preference : string
  member Surname : string

--------------------
new : id:int * name:string * surname:string * preference:string -> Item
val id : int
Multiple items
val int : value:'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
val name : string
Multiple items
val string : value:'T -> string

--------------------
type string = String
val surname : string
val preference : string
val this : Item
val getNewRecord : rnd:Random * id:int -> Item
val names : string list
val surnames : string list
val prefs : string list
val curName : string
val curSurname : string
val curPref : string
val myItem : Item
val formM : obj
Multiple items
type Size =
  struct
    new : pt:Point -> Size + 1 overload
    member Equals : obj:obj -> bool + 1 overload
    member GetHashCode : unit -> int
    member Height : int with get, set
    member IsEmpty : bool
    member ToString : unit -> string
    member Width : int with get, set
    static val Empty : Size
    static member Add : sz1:Size * sz2:Size -> Size
    static member Ceiling : value:SizeF -> Size
    ...
  end

--------------------
Size ()
Size(pt: Point) : Size
Size(width: int, height: int) : Size
val input : obj
val bindingSource : obj
val button : obj
val output : obj
val ignore : value:'T -> unit
type Color =
  struct
    member A : byte
    member B : byte
    member Equals : obj:obj -> bool + 1 overload
    member G : byte
    member GetBrightness : unit -> float32
    member GetHashCode : unit -> int
    member GetHue : unit -> float32
    member GetSaturation : unit -> float32
    member IsEmpty : bool
    member IsKnownColor : bool
    ...
  end
Color.FromArgb(argb: int) : Color
Color.FromArgb(alpha: int, baseColor: Color) : Color
Color.FromArgb(red: int, green: int, blue: int) : Color
Color.FromArgb(alpha: int, red: int, green: int, blue: int) : Color
property Color.Beige: Color with get
val convertToDataTable : data:List<'T> -> DataTable
val data : List<'T>
Multiple items
type List<'T> =
  new : unit -> List<'T> + 2 overloads
  member Add : item:'T -> unit
  member AddRange : collection:IEnumerable<'T> -> unit
  member AsReadOnly : unit -> ReadOnlyCollection<'T>
  member BinarySearch : item:'T -> int + 2 overloads
  member Capacity : int with get, set
  member Clear : unit -> unit
  member Contains : item:'T -> bool
  member ConvertAll<'TOutput> : converter:Converter<'T, 'TOutput> -> List<'TOutput>
  member CopyTo : array:'T[] -> unit + 2 overloads
  ...
  nested type Enumerator

--------------------
List() : List<'T>
List(capacity: int) : List<'T>
List(collection: IEnumerable<'T>) : List<'T>
val properties : PropertyDescriptorCollection
type TypeDescriptor =
  static member AddAttributes : type:Type * [<ParamArray>] attributes:Attribute[] -> TypeDescriptionProvider + 1 overload
  static member AddEditorTable : editorBaseType:Type * table:Hashtable -> unit
  static member AddProvider : provider:TypeDescriptionProvider * type:Type -> unit + 1 overload
  static member AddProviderTransparent : provider:TypeDescriptionProvider * type:Type -> unit + 1 overload
  static member ComNativeDescriptorHandler : IComNativeDescriptorHandler with get, set
  static member ComObjectType : Type
  static member CreateAssociation : primary:obj * secondary:obj -> unit
  static member CreateDesigner : component:IComponent * designerBaseType:Type -> IDesigner
  static member CreateEvent : componentType:Type * oldEventDescriptor:EventDescriptor * [<ParamArray>] attributes:Attribute[] -> EventDescriptor + 1 overload
  static member CreateInstance : provider:IServiceProvider * objectType:Type * argTypes:Type[] * args:obj[] -> obj
  ...
TypeDescriptor.GetProperties(component: obj) : PropertyDescriptorCollection
TypeDescriptor.GetProperties(componentType: Type) : PropertyDescriptorCollection
TypeDescriptor.GetProperties(component: obj, attributes: Attribute []) : PropertyDescriptorCollection
TypeDescriptor.GetProperties(component: obj, noCustomTypeDesc: bool) : PropertyDescriptorCollection
TypeDescriptor.GetProperties(componentType: Type, attributes: Attribute []) : PropertyDescriptorCollection
TypeDescriptor.GetProperties(component: obj, attributes: Attribute [], noCustomTypeDesc: bool) : PropertyDescriptorCollection
val typedefof<'T> : Type
val table : DataTable
Multiple items
type DataTable =
  inherit MarshalByValueComponent
  new : unit -> DataTable + 2 overloads
  member AcceptChanges : unit -> unit
  member BeginInit : unit -> unit
  member BeginLoadData : unit -> unit
  member CaseSensitive : bool with get, set
  member ChildRelations : DataRelationCollection
  member Clear : unit -> unit
  member Clone : unit -> DataTable
  member Columns : DataColumnCollection
  member Compute : expression:string * filter:string -> obj
  ...

--------------------
DataTable() : DataTable
DataTable(tableName: string) : DataTable
DataTable(tableName: string, tableNamespace: string) : DataTable
val prop : PropertyDescriptor
type PropertyDescriptor =
  inherit MemberDescriptor
  member AddValueChanged : component:obj * handler:EventHandler -> unit
  member CanResetValue : component:obj -> bool
  member ComponentType : Type
  member Converter : TypeConverter
  member Equals : obj:obj -> bool
  member GetChildProperties : unit -> PropertyDescriptorCollection + 3 overloads
  member GetEditor : editorBaseType:Type -> obj
  member GetHashCode : unit -> int
  member GetValue : component:obj -> obj
  member IsLocalizable : bool
  ...
val item : 'T
val row : DataRow
val iter : action:('T -> unit) -> list:'T list -> unit
Multiple items
type Object =
  new : unit -> obj
  member Equals : obj:obj -> bool
  member GetHashCode : unit -> int
  member GetType : unit -> Type
  member ToString : unit -> string
  static member Equals : objA:obj * objB:obj -> bool
  static member ReferenceEquals : objA:obj * objB:obj -> bool

--------------------
Object() : Object
val dc : c:'a -> 'b
val c : 'a
namespace Microsoft.FSharp.Control
val onInpTextChanged : sender:Object * e:EventArgs -> unit
val sender : Object
val e : EventArgs
Multiple items
type EventArgs =
  new : unit -> EventArgs
  static val Empty : EventArgs

--------------------
EventArgs() : EventArgs
type unit = Unit
val bd : obj
val dt : DataTable
val str : string
Multiple items
type String =
  new : value:char[] -> string + 8 overloads
  member Chars : int -> char
  member Clone : unit -> obj
  member CompareTo : value:obj -> int + 1 overload
  member Contains : value:string -> bool + 3 overloads
  member CopyTo : sourceIndex:int * destination:char[] * destinationIndex:int * count:int -> unit
  member EndsWith : value:string -> bool + 3 overloads
  member EnumerateRunes : unit -> StringRuneEnumerator
  member Equals : obj:obj -> bool + 2 overloads
  member GetEnumerator : unit -> CharEnumerator
  ...

--------------------
String(value: char []) : String
String(value: nativeptr<char>) : String
String(value: nativeptr<sbyte>) : String
String(value: ReadOnlySpan<char>) : String
String(c: char, count: int) : String
String(value: char [], startIndex: int, length: int) : String
String(value: nativeptr<char>, startIndex: int, length: int) : String
String(value: nativeptr<sbyte>, startIndex: int, length: int) : String
String(value: nativeptr<sbyte>, startIndex: int, length: int, enc: Encoding) : String
String.Format(format: string, [<ParamArray>] args: obj []) : string
String.Format(format: string, arg0: obj) : string
String.Format(provider: IFormatProvider, format: string, [<ParamArray>] args: obj []) : string
String.Format(provider: IFormatProvider, format: string, arg0: obj) : string
String.Format(format: string, arg0: obj, arg1: obj) : string
String.Format(provider: IFormatProvider, format: string, arg0: obj, arg1: obj) : string
String.Format(format: string, arg0: obj, arg1: obj, arg2: obj) : string
String.Format(provider: IFormatProvider, format: string, arg0: obj, arg1: obj, arg2: obj) : string
Multiple items
type EventHandler<'TEventArgs> =
  delegate of obj * 'TEventArgs -> unit

--------------------
type EventHandler =
  delegate of obj * EventArgs -> unit
Multiple items
type STAThreadAttribute =
  inherit Attribute
  new : unit -> STAThreadAttribute

--------------------
STAThreadAttribute() : STAThreadAttribute

More information

Link:http://fssnip.net/85z
Posted:2 years ago
Author:Vladimir Demydov
Tags: datagrid , windows forms , winforms

This web site is created using F# and Suave web server. It is hosted on Azure and the source code is on GitHub. Contributions are welcome!

The first version of fssnip.net has been created by @tomaspetricek back in 2010. This web site is a new, open-source and contribution-friendly version.