Parent Child Relationship in SQL – Manual DataSet Relations

DataSet Relations: जिस तरह से हमने पिछले Example Program में एक Strongly Typed DataSet Object को Use करते हुए किसी Record के Child Records व Parent Records को Access किया है, जिसमें Indirect तरीके से DataRelation Object Participate कर रहा है, ठीक इसी उदाहरण को हम Simple DataSet Object के माध्‍यम से भी निम्नानुसार Redesign कर सकते हैं:

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Windows.Forms;

namespace SearchingSortingFiltering
{
    public partial class frmAccessingMultipleTable : Form
    {
        public frmAccessingMultipleTable()
        {
            InitializeComponent();
        }
        private void btnExit_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private string connectionString = null;
        private SqlConnection con = null;

        private SqlDataAdapter daCustomers = null;
        private SqlDataAdapter daOrders = null;
        private SqlDataAdapter daProducts = null;
        private SqlDataAdapter daOrder_Details = null;

        private DataSet ds = new DataSet("Northwind");

        private DataTable dtCustomers = new DataTable("Customers");
        private DataTable dtOrders = new DataTable("Orders");
        private DataTable dtProducts = new DataTable("Products");
        private DataTable dtOrder_Details = new DataTable("Order_Details");

        DataRelation drRelation = null;

        private void btnShowOrders_Click(object sender, EventArgs e)
        {
            if (lbCustomers.SelectedIndex < 0)
            {
                return;
            }

            //Getting Selected Customer Row
            DataRow rowCustomer = ds.Tables["Customers"].Rows[lbCustomers.SelectedIndex];
            lbOrders.Items.Clear();


            foreach (DataRow rowOrder in rowCustomer.GetChildRows("Customer2Order"))
            //Following Statement is Also Valid
            //foreach (DataRow rowOrder in rowCustomer.GetChildRows(drRelation))
            {
                lbOrders.Items.Add(rowOrder["OrderID"] + ": " + rowOrder["OrderDate"]);
            }
        }

        private void frmAccessingMultipleTable_Load(object sender, EventArgs e)
        {
            //Configuring Connection String and Creating Connection
            this.connectionString= "Data Source=.\\SQLSERVEREXPRESS;Initial Catalog=Northwind;Integrated Security=True";
            con = new SqlConnection(this.connectionString);

            //Configuring DataAdapter for Get/Set Data from/to Underlying Database
            daCustomers = new SqlDataAdapter("SELECT * FROM Customers", con);
            daOrders = new SqlDataAdapter("SELECT * FROM Orders", con);
            daProducts = new SqlDataAdapter("SELECT * FROM Products", con);
            daOrder_Details = new SqlDataAdapter("SELECT * FROM [Order Details]", con);

            //Filling DataTables with Underlying DataTable Rows
            daCustomers.Fill(dtCustomers);
            daOrders.Fill(dtOrders);
            daProducts.Fill(dtProducts);
            daOrder_Details.Fill(dtOrder_Details);

            //Adding All DataTables to DataSet Object
            ds.Tables.Add(dtCustomers);
            ds.Tables.Add(dtOrders);
            ds.Tables.Add(dtProducts);
            ds.Tables.Add(dtOrder_Details);

            //Setting Child Relationship between Customers to Orders DataTables
            drRelation = new DataRelation(
                "Customer2Order",
                ds.Tables["Customers"].Columns["CustomerID"],
                ds.Tables["Orders"].Columns["CustomerID"]);
            ds.Relations.Add(drRelation);

            //Setting Child Relationship between Orders to Order_Details DataTables
            drRelation = new DataRelation(
                "Orders2OrderDetails",
                dtOrders.Columns["OrderID"],
                dtOrder_Details.Columns["OrderID"]);
            ds.Relations.Add(drRelation);

            //Setting Parent Relationship between Order_Details to Products DataTables
            drRelation = new DataRelation(
                "Products2OrderDetails",
                dtProducts.Columns["ProductID"],
                dtOrder_Details.Columns["ProductID"]);
            ds.Relations.Add(drRelation);

            foreach (DataRow drCustomer in ds.Tables["Customers"].Rows)
            {
                lbCustomers.Items.Add(drCustomer["CustomerID"] +": "+drCustomer["ContactName"]);
            }
        }

        private void btnShowOrderDetails_Click(object sender, EventArgs e)
        {
            if (lbOrders.SelectedIndex < 0)
            {
                return;
            }

            DataRow rowOrder = ds.Tables["Orders"].Rows[lbOrders.SelectedIndex];
            lbOrderDetails.Items.Clear();

            foreach (DataRow rowOrderDetail in rowOrder.GetChildRows("Orders2OrderDetails"))
            {
                lbOrderDetails.Items.Add("ProductID: " + rowOrderDetail["ProductID"]);
            }
        }

        private void btnShowOrderedProducts_Click(object sender, EventArgs e)
        {
            if (lbOrders.SelectedIndex < 0)
            {
                return;
            }
            DataRow rowOrder = ds.Tables["Orders"].Rows[lbOrders.SelectedIndex];

            lbProducts.Items.Clear();
            foreach (DataRow rowOrderDetail in rowOrder.GetChildRows("Orders2OrderDetails"))
            {
                DataRow rowProduct = rowOrderDetail.GetParentRow("Products2OrderDetails");
                lbProducts.Items.Add(rowProduct["ProductName"]);
            }
        }
    }
}

Strongly Typed DataSet व Simple DataSet दोनों ही प्रकार के Objects का प्रयोग करके हम Hierarchical Form में Related Tables के Records को Access व Manipulate कर सकते हैं। लेकिन दोनों ही तरीकों को Use करने के अपने फायदे व नुकसान है।

यदि हम Strongly Typed DataSet Object को Use करते हैं, तो हालांकि Application Develop करते समय हम Strongly Typed नामों को Use करते हैं, जो कि Base Classes यानी DataSet, DataTables, DataView, DataAdapter, DataRelation आदि की Extended Classes होती हैं, इसलिए इस एक और Level के Inheritance के कारण Strongly Typed Objects को Use करते हुए Develop किया गया Application हालांकि कम Coding से Develop किया जाना सम्भव हो जाता है।

लेकिन इस प्रकार के Applications की तुलना में Simple DataSet, DataTable, DataRelation, DataView आदि Objects को Use करने पर बनने वाले Application की Performance तुलनात्मक रूप से अधिक बेहतर होती है। हालांकि Simple Objects Use करने पर हमें ज्यादा Codes लिखने पडते हैं और अपने Codes को अपने स्तर पर ही Maintain करना पडता है।

साथ ही छोटे Application के लिए Strongly Typed DataSet Objects को उपयोग में लेते हुए Application Design व Maintain करना आसान होता है, लेकिन जब हम बडे Application Software Develop करते हैं, तब Strongly Typed Objects को Use करने पर Application को Design, Develop व Maintain करना तुलनात्मक रूप से कठिन हो जाता है।

इसलिए बडे व जटिल Applications Develop करते समय हम सामान्यत: Strongly Typed Objects को Use नहीं करते। जबकि सबसे बेहतर Approach पूरी तरह से हमारी Requirement पर निर्भर करता है। यानी हम हमारी जरूरत के अनुसार Mixed Model भी Use कर सकते हैं, जिसमें कुछ Objects Strongly Typed होते हैं, जबकि कुछ Simple Objects पर आधारित होते हैं।

जब हम हमारे इस Example Program को Run करते हैं, तो Form के Memory में Load होते ही Form Load होने के Event के Response में सबसे पहले हमारी Form की Class में निम्नानुसार Codes के माध्‍यम से कुछ नई Properties Setup होती हैं:

        private string connectionString = null;
        private SqlConnection con = null;

        private SqlDataAdapter daCustomers = null;
        private SqlDataAdapter daOrders = null;
        private SqlDataAdapter daProducts = null;
        private SqlDataAdapter daOrder_Details = null;

        private DataSet ds = new DataSet("Northwind");

        private DataTable dtCustomers = new DataTable("Customers");
        private DataTable dtOrders = new DataTable("Orders");
        private DataTable dtProducts = new DataTable("Products");
        private DataTable dtOrder_Details = new DataTable("Order_Details");

        DataRelation drRelation = null;

हम देख सकते हैं कि चूंकि हम चार Tables को आपस में Related करते हुए Processing करना चाहते हैं और चारों ही Tables Northwind Database में Stored है, जो कि एक MSSQL Server Database है, इसीलिए हमने चारों Tables के Data को Access व Manipulate करने के लिए SqlDataAdapter Type के चार Objects Declare किए हैं। फिर ds नाम का एक नया DataSet Object Create किया है, जिसका नाम “Northwind” रखा है।

DataAdapters व DataSet Objects Create करने के बाद हमने चारों Tables के Data को DataSet Object में DataTables की तरह Represent करने के लिए चार DataTable Type के Objects भी Create किए हैं, जहां चारों DataTables का नाम Underlying Database की Physical Tables के नाम के समान ही Customers, Orders, Products व Order_Details हैं। ये वे नाम हैं, जिन्हें हम हमारे DataSet Object के Tables Collection द्वारा Reference कर सकते हैं।

अन्तिम Line के Code के रूप में हमने एक DataRelation Object Declare किया है, जिसका प्रयोग करके हम अपने DataSet Object में Contained विभिन्न DataTable Objects के बीच की Relationship को Configure कर सकते हैं, ताकि हम एक से ज्यादा DataTables के Records को Access व Manipulate कर सकें।

इन Properties के Configure होने के बाद तथा Fore के पूरी तरह से Initialize हो जाने के बाद जब Form Memory में Load होता है, तो Form Load Event Handler Code Execute होता है जो उपरोक्तानुसार Declare की गई विभिन्न Properties को Setup करता है, ताकि पूरे Form के दौरान Define किए गए विभिन्न Methods, Event Handlers व Objects इन Properties को Common रूप से Use करते हुए अपने Operations को Perform कर सकें। इस Form के Memory में Load होते ही निम्न Code Execute होता है:

            //Configuring Connection String and Creating Connection
            this.connectionString="Data Source=.\\SQLSERVEREXPRESS;Initial Catalog=Northwind;Integrated Security=True";
            con = new SqlConnection(this.connectionString);

करता है और अगले Statement के माध्‍यम से इस connectionString Property को SqlConnection Type के con नाम की Property को Setup किया गया है, ताकि विभिन्न DataAdapter Objects, Underlying Database से Connection स्थापित करने के लिए इस Connection Object को Use कर सकें। इ दोनों Statement के Execution के बाद निम्न Statements का Execution होता है:

            //Configuring DataAdapter for Get/Set Data from/to Underlying Database
            daCustomers = new SqlDataAdapter("SELECT * FROM Customers", con);
            daOrders = new SqlDataAdapter("SELECT * FROM Orders", con);
            daProducts = new SqlDataAdapter("SELECT * FROM Products", con);
            daOrder_Details = new SqlDataAdapter("SELECT * FROM [Order Details]", con);

ये चारों Statements चार DataAdapter Objects को Setup करते हैं, जिनके माध्‍यम से ये त; होता है कि किस DataTable में Underlying Database के कौनसे Records Fill होंगे, जबकि Underlying Database से Connection Establish करने के लिए किस Connection Object का प्रयोग किया जाएगा।

यहां हमने चार अलग DataAdapter Objects Create किए हैं, ताकि आप आसानी से समझ सकें कि Program किस तरह से Flow हो रहा है। जबकि यदि हम चाहें, तो इन चारों Statements को एक Single Statement के रूप में भी Specify कर सकते हैं, जिसके लिए केवल एक DataAdapter Object की ही जरूरत होती है। जैसे:

SqlDataAdapter da4All = new SqlDataAdapter(
	"SELECT * FROM Customers;
	SELECT * FROM Orders;
	SELECT * FROM Products;
	SELECT * FROM [Order Details]", con);

DataAdapter Setup करने के बाद निम्न Codes Execute होते हैं:

            //Adding All DataTables to DataSet Object
            ds.Tables.Add(dtCustomers);
            ds.Tables.Add(dtOrders);
            ds.Tables.Add(dtProducts);
            ds.Tables.Add(dtOrder_Details);

ये Statements हमारी चारों DataTables को ds नाम के हमारे DataSet Object में Add कर देते हैं।

.NET Framework हमें ऐसी सुविधा Provide करता है कि हम एक ही काम को कई तरीकों से पूरा कर सकते हैं और यही बात उपरोक्त Code पर भी Apply होती है, जहां हमने चार अलग DataTable Objects Create किए हैं, इसलिए चारों DataTable Objects को DataSet Object में Add करने के लिए हमने उपरोक्तानुसार Statements का प्रयोग किया है।

जबकि यदि हम चाहें तो बिना चार अलग DataTable Objects Crate किए हुए सीधे ही DataSet Object के Tables Collection में निम्नानुसार तरीके से भी चारों DataTables को Add कर सकते हैं:

            ds.Tables.Add(new DataTable("Customers"));
            ds.Tables.Add(new DataTable("Orders"));
            ds.Tables.Add(new DataTable("Products"));
            ds.Tables.Add(new DataTable("Order_Details"));

विभिन्न DataTables को DataSet Object में Add करने के बाद अब निम्न Statements का Execution होता है:

            //Filling DataTables with Underlying DataTable Rows
            daCustomers.Fill(dtCustomers);
            daOrders.Fill(dtOrders);
            daProducts.Fill(dtProducts);
            daOrder_Details.Fill(dtOrder_Details);

ये Codes चारों DataTables को Underlying Database पर SQL Query Fire करके Appropriate Records से Fill कर देते हैं। जबकि यदि हमने चार अलग DataAdapter Create करने के स्थान पर उपरोक्तानुसार da4All नाम का एक Single DataAdapter Create किया होता, तो ds नाम के DataSet Object की चारों DataTables में Data Fill करने के लिए हमें निम्नानुसार Statements का प्रयोग करना पडता:

            da4All.Fill(ds.Tables["Customers"]);
            da4All.Fill(ds.Tables["Orders"]);
            da4All.Fill(ds.Tables["Products"]);
            da4All.Fill(ds.Tables["Order_Details"]);

सभी DataTables में Data Fill होने के बाद निम्नानुसार DataRelation Code Execute होता है:

            //Setting Child Relationship between Customers to Orders DataTables
            drRelation = new DataRelation(
                "Customer2Order",
                ds.Tables["Customers"].Columns["CustomerID"],
                ds.Tables["Orders"].Columns["CustomerID"]);
            ds.Relations.Add(drRelation);

ये Code Execute होते ही DataRelation Type के drRelation नाम के DataRelation Type के Object में एक Relationship Configuration Specify करता है, जिसके माध्‍यम से Customers व Orders Table के Records One-to-Many की Relationship यानी Parent/Child या Master/Detail Relationship से Bound हो जाते हैं और इस Relationship का नाम “Customer2Order” Set कर दिया जाता है।

क्योंकि इस उदाहरण में हमने Strongly Typed Objects का प्रयोग नहीं किया है, इसलिए इस Example में विभिन्न Objects को Access करने के लिए हमें किसी प्रकार का कोई Strongly Typed Object प्राप्त नहीं होता। जिसकी वजह से हमें निम्नानुसार Declarative Syntax का प्रयोग करते हुए ही Customers व Orders Table के CustomerID Column को Reference करना पड रहा है:

ds.Tables["Customers"].Columns["CustomerID"], ds.Tables["Orders"].Columns["CustomerID"]);

चूंकि इस उदाहरण Program में हमने हर Table के लिए एक अलग DataTable Object Create किया है, इसलिए यदि हम चाहें तो हालांकि हमारे DataTables, ds नाम के DataSet Object में Contained हैं, फिर भी हम इन DataTables को Directly Access कर सकते हैं और अगले Relationship Statement में हमने यही किया है:

            //Setting Child Relationship between Orders to Order_Details DataTables
            drRelation = new DataRelation(
                "Orders2OrderDetails",
                dtOrders.Columns["OrderID"],
                dtOrder_Details.Columns["OrderID"]);
            ds.Relations.Add(drRelation);

इस Code द्वारा हमने पिछले Code की तरह ही एक Relationship Establish किया है, जिसके माध्‍यम से Orders Table के Record के लिए Order_Details Table के सभी Records को Reference करने की सुविधा प्राप्त होती है, जबकि इस Relationship को Represent करने के लिए इसका नाम “Orders2OrderDetails” रखा है।

हम देख सकते हैं कि इस Code में हमने पिछले Code की तरह DataTable को DataSet Object के Tables Collection के माध्‍यम से Access नहीं किया है, बल्कि सीधे ही dtOrders व dtOrder_Details नाम से निम्नानुसार Reference किया है:

dtOrders.Columns["OrderID"], dtOrder_Details.Columns["OrderID"]

जबकि इन्हीं Statements को निम्नानुसार भी लिखा जा सकता है:

ds.Tables["Orders"].Columns["OrderID"], ds.Tables["Order_Details"].Columns["OrderID"]);

इस Statement के Execute होने के बाद निम्नानुसार एक और Relationship Statement Execute होता है:

            //Setting Parent Relationship between Order_Details to Products DataTables
            drRelation = new DataRelation(
                "Products2OrderDetails",
                dtProducts.Columns["ProductID"],
                dtOrder_Details.Columns["ProductID"]);
            ds.Relations.Add(drRelation);

ये Statement Products व Order_Details Table के बीच की Relationship को Specify करता है।

उपरोक्तानुसार तीन Relationship Objects Create होने के बाद हमें इन्हें अपने DataSet Object की Relations Property में Add करना होता है, ताकि DataSet Object को इस बात की जानकारी प्राप्त हो सके कि उसमें Contained विभिन्न DataTables आपस में किस प्रकार से Related हैं।

इस काम को पूरा करने के लिए उपरोक्तानुसार हर Relationship को Specify करने के बाद अन्त में निम्नानुसार Statement द्वारा सभी Relationships को DataSet Object की Relations Property में Add किया गया है:

ds.Relations.Add(drRelation);

यहां भी यदि हम चाहें तो नया DataRelation Object Create करने के स्थान पर सीधे ही Anonymous DataRelations को DataSet Object की Relations Property में निम्नानुसार Add कर सकते हैं:

            //Setting Child Relationship between Customers to Orders DataTables
            ds.Relations.Add(new DataRelation(
                "Customer2Order",
                ds.Tables["Customers"].Columns["CustomerID"],
                ds.Tables["Orders"].Columns["CustomerID"]));
            
            //Setting Child Relationship between Orders to Order_Details DataTables
            ds.Relations.Add(new DataRelation(
                "Orders2OrderDetails",
                dtOrders.Columns["OrderID"],
                dtOrder_Details.Columns["OrderID"]));

            //Setting Parent Relationship between Order_Details to Products DataTables
            ds.Relations.Add(new DataRelation(
                "Products2OrderDetails",
                dtProducts.Columns["ProductID"],
                dtOrder_Details.Columns["ProductID"]));

DataTables के बीच की Relationship को Configure करने के बाद अन्त में निम्नानुसार foreach Statement द्वारा Customers DataTable के CustomerID + ContactName को lbCustomers नाम के ListBox Control के Items Collection में Add कर देता है, जो कि Syntax के अलावा Concept के मामले में Exactly वैसा ही काम करता है, जैसा पिछले Example में कर रहा था:

            foreach (DataRow drCustomer in ds.Tables["Customers"].Rows)
            {
               lbCustomers.Items.Add(drCustomer["CustomerID"]+ ": " +drCustomer["ContactName"]);
            }

इस Code के Execute होने के बाद हमारा Form पूरी तरह से Load हो जाता है, परिणामस्वरूप हमें हमारा Main Form निम्नानुसार दिखाई देने लगता है:

जब हम इस Form पर दिखाई देने वाले पहले “Child Rows >>” Button पर Click करते हैं, तो निम्नानुसार Click Event Handler Execute होता है:

        private void btnShowOrders_Click(object sender, EventArgs e)
        {
            if (lbCustomers.SelectedIndex < 0)
            {
                return;
            }

            //Getting Selected Customer Row
            DataRow rowCustomer = ds.Tables["Customers"].Rows[lbCustomers.SelectedIndex];

            lbOrders.Items.Clear();

            foreach (DataRow rowOrder in rowCustomer.GetChildRows("Customer2Order"))
            {
                lbOrders.Items.Add(rowOrder["OrderID"] + ": " + rowOrder["OrderDate"]);
            }
        }

ये Code भी Exactly पिछले Example वाले Code की तरह ही काम करता है, अन्तर केवल इन्हें लिखने के तरीके में है। इस Code में lbCustomers ListBox Control में Selected Customer के Row को ds DataSet Object के Customers DataTable से Retrieve करके rowCustomer Object में Store करने के लिए निम्नानुसार Statement का प्रयोग किया गया है:

DataRow rowCustomer = ds.Tables[“Customers”].Rows[lbCustomers.SelectedIndex];

और फिर इस rowCustomer DataRow Object में Stored Customer के Row से Match करने वाले सभी Child Rows यानी Orders DataTable में Stored Related Order Rows को One-by-One Retrieve करने के लिए निम्नानुसार foreach Statement का प्रयोग किया गया है:

foreach (DataRow rowOrder in rowCustomer.GetChildRows(“Customer2Order”))

इस Foreach Statement में GetChildRows() Method का प्रयोग किया गया है, जबकि Strongly Typed Objects को Use करते समय इसी प्रकार की समान जरूरत को पूरा करने के लिए Get{TableName}.Rows() Method को Use किया गया था।

यानी जिस जरूरत को पूरा करने के लिए Strongly Typed Objects का प्रयोग करते समय हमें Get{TableName}.Rows() नाम का Strongly Typed Method Use करना होता है, उसी जरूरत को पूरा करने के लिए Non-Strongly Typed Objects का प्रयोग करते समय हमें GetChildRows() Method को Use करना होता है।

चूंकि Strongly Typed Objects का प्रयोग करते समय Visual Studio स्वयं अपने स्तर पर DataRelation Object को अपने स्तर पर स्वं; Internally Use करता है, इसलिए Child Records को Retrieve करने के लिए हमें Get{TableName}.Rows() Method को Invoke करने के अलावा और कुछ भी Special नहीं करना होता।

लेकिन जब हम Non-Strongly Typed Objects का प्रयोग करते हैं, तब Child Rows को Retrieve करने के लिए हमें GetChildRows() Method में Argument के रूप में उस Relationship का नाम Specify करना जरूरी होता है, जिसके माध्‍यम से Child Table से Parent व Child DataTable के बीच की Relationship को Setup किया गया है।

इसीलिए हमारे इस Code में हमने “Customer2Order” नाम की Relationship को Argument के रूप में Specify किया है, क्योंकि इसी Relationship को Customers व Orders Table के बीच की One-to-Many की Relationship को Setup करने के लिए Configure किया गया था।

ठीक इसी प्रकार से जब हम Form पर दिखाई देने वाले दूसरे “Child Rows >>” Button पर Click करते हैं, तो निम्न Event Handler Code Execute होता है, जो कि Exactly पिछले Code की तरह ही काम करता है और Form पर दिखाई देने वाले lbOrders नाम के ListBox में दिखाई देने वाले Orders में से जिस Order को Select किया जाता है, उस Order की Details को Form पर दिखाई देने वाले lbOrderDetails नाम के ListBox Control के Items Collection में Add कर देता है:

        private void btnShowOrderDetails_Click(object sender, EventArgs e)
        {
            if (lbOrders.SelectedIndex < 0)
            {
                return;
            }

            DataRow rowOrder = ds.Tables["Orders"].Rows[lbOrders.SelectedIndex];
            lbOrderDetails.Items.Clear();

            foreach (DataRow rowOrderDetail in rowOrder.GetChildRows("Orders2OrderDetails"))
            {
                lbOrderDetails.Items.Add("ProductID: " + rowOrderDetail["ProductID"]);
            }
        }

जैसाकि इस Code में हम देख सकते हैं कि इस बार हमने GetChildRows() Method में Relationship के नाम के रूप में “Orders2OrderDetails” नाम को Parameter की तरह Pass किया है, ताकि rowOrder Object में Stored Parent Order Row के लिए Order_Details DataTable से Child Rows को One-by-One Retrieve किया जा सके।

क्योंकि इन दोनों DataTables को आपस में Relate करने के लिए हमने जो DataRelation Configure करके ds नाम DataSet Object के Relations Collection में Add किया था, उसका नाम हमने Orders2OrderDetails रखा था, जिसे इस Statement में Parameter की तरह Pass किया है।

इसी प्रकार से जब हम “Parent Rows >>” Button पर Click करते हैं, तो Trigger होने वाले Click Event को Handle करने के लिए निम्नानुसार Event Handler Code Execute होता है:

        private void btnShowOrderedProducts_Click(object sender, EventArgs e)
        {
            if (lbOrders.SelectedIndex < 0)
            {
                return;
            }
            DataRow rowOrder = ds.Tables["Orders"].Rows[lbOrders.SelectedIndex];

            lbProducts.Items.Clear();
            foreach (DataRow rowOrderDetail in rowOrder.GetChildRows("Orders2OrderDetails"))
            {
                DataRow rowProduct = rowOrderDetail.GetParentRow("Products2OrderDetails");
                lbProducts.Items.Add(rowProduct["ProductName"]);
            }
        }

जैसाकि इस Code द्वारा हम समझ सकते हैं कि जब हम Strongly Typed Objects Use करते हैं, तब Child Records को Retrieve करने के लिए हमें Get{TableName}.Rows() नाम का Method प्राप्त होता है, जिसके Alternative के रूप में हमें GetChildRows() नाम का Method प्राप्त होता है, जो हमें Non-Strongly Typed Objects के माध्‍यम से Child Rows को Access करने की सुविधा देता है।

ठीक इसी प्रकार से जब हम Strongly Typed Objects Use करते हैं, तब किसी Child Record के Parent Record को Retrieve करने के लिए हमें {TableName}.Rows() नाम का Method प्राप्त होता है, जिसके Alternative के रूप में हमें GetChildRows() नाम का Method प्राप्त होता है, जो हमें Non-Strongly Typed Objects के माध्‍यम से किसी Child Record के Parent Record को Access करने की सुविधा देता है।