C#

class Complex
{
    private double real;                // member #1
    private double imag;                // member #2

    // Constructors
    public Complex()
    {
        real = 0.0;
        imag = 0.0;
    }

    public Complex(double x)
    {
        real = x;
        imag = 0.0;
    }

    public Complex(double x, double y)
    {
        real = x;
        imag = y;
    }

    // property
    public double Real { get; set; }

    // method
    public double norm()
    {
        return real * real + imag * imag;
    }
};

public abstract class HierarchyBase : INotifyPropertyChanged
   {

       private ObservableCollection<HierarchyBase> children = new ObservableCollection<HierarchyBase>();

       public ObservableCollection<HierarchyBase> Children
       {
           get { return children; }
           set { children = value; }
       }


       public string Name { get; set; }

       private bool pIsEnabled;
       public bool IsEnabled
       {
           get { return pIsEnabled; }
           set { pIsEnabled = value;
               StateUpdated();
               OnPropertyChanged();
           }
       }

       private bool pIsVisible;

       public bool IsVisible
       {
           get { return pIsVisible; }
           set {
               pIsVisible = value;
               StateUpdated();
               OnPropertyChanged();
           }
       }

       private void StateUpdated()
       {
           if (this is IDrawing)
           {
               ((IDrawing)this).Redraw(IsVisible);
           }

           foreach (HierarchyBase child in Children)
           {
               if (!this.IsEnabled || !this.IsVisible)
               {
                   child.IsVisible = false;
               }
           }
       }

       public event PropertyChangedEventHandler PropertyChanged;

       private void OnPropertyChanged([CallerMemberName]string caller = "")
       {
           // make sure only to call this if the value actually changes

           var handler = PropertyChanged;
           if (handler != null)
           {
               handler(this, new PropertyChangedEventArgs(caller));
               StateUpdated();
           }
       }
   }

<TreeView x:Name="tree">
    <TreeView.Resources>
        <HierarchicalDataTemplate DataType="{x:Type local:HierarchyBase}" ItemsSource="{Binding Children}" >
            <TextBox Text="{Binding Name}"/>
        </HierarchicalDataTemplate>
    </TreeView.Resources>
</TreeView>

public abstract class HierarchyBase : INotifyPropertyChanged
   {
       public HierarchyBase()
       {
           Delete = new RelayCommand( CanDelete, DeleteThis);
           children.CollectionChanged +=ItemChildren_CollectionChanged;
       }

       public Canvas myCanvas;
       private HierarchyBase _parent;

       private void ItemChildren_CollectionChanged(object sender,NotifyCollectionChangedEventArgs e)
       {
           //different kind of changes that may have occurred in collection
           if (e.Action == NotifyCollectionChangedAction.Add)
           {
               foreach (var item in e.NewItems)
               {
                   ((HierarchyBase)item)._parent = this;
                   ((HierarchyBase)item).myCanvas = this.myCanvas;
               }
               //((List<object>)e.NewItems).ForEach(i => ((HierarchyBase)i)._parent = this); // foreach (e.NewItems)(i => i;)

           }
           if (e.Action == NotifyCollectionChangedAction.Replace)
           {
               //your code
           }
           if (e.Action == NotifyCollectionChangedAction.Remove)
           {
               foreach (var item   in e.OldItems)
               {
                   ((HierarchyBase)item)._parent = null;
                   ((HierarchyBase)item).myCanvas = null;
               }
           }
           if (e.Action == NotifyCollectionChangedAction.Move)
           {
               //your code
           }
       }

       private ObservableCollection<HierarchyBase> children = new ObservableCollection<HierarchyBase>();


       public ObservableCollection<HierarchyBase> Children
       {
           get { return children; }
           set { children = value; }
       }

       public ICommand Delete { get; set; }

       private bool CanDelete(object obj)
       {
           return IsEnabled;
       }

       private void DeleteThis(object obj)
       {
           this._parent.Children.Remove(this);
       }

       public string Name { get; set; }

       private bool pIsEnabled = true;
       public bool IsEnabled
       {
           get { return pIsEnabled; }
           set { pIsEnabled = value;
               OnPropertyChanged();
           }
       }

       private bool pIsVisible = true;

       public bool IsVisible
       {
           get { return pIsVisible; }
           set {
               pIsVisible = value;
               OnPropertyChanged();
           }
       }

       private void StateUpdated()
       {
           if (this is IDrawing)
           {
               ((IDrawing)this).Redraw(IsVisible);
           }

           foreach (HierarchyBase child in Children)
           {
               if (!this.IsEnabled || !this.IsVisible)
               {
                   child.IsVisible = false;
               }
           }
       }

       public event PropertyChangedEventHandler PropertyChanged;

       private void OnPropertyChanged([CallerMemberName]string caller = "")
       {
           // make sure only to call this if the value actually changes

           var handler = PropertyChanged;
           if (handler != null)
           {
               handler(this, new PropertyChangedEventArgs(caller));
               StateUpdated();
           }
       }
   }

object o = dt.Rows [0] ["NOIDUNG"];
string s = o.ToString ();

Debug.Print(dt.Rows[0]["NOIDUNG"].ToString());

Debug.Print(Convert.ToString(dt.Rows[0]["NOIDUNG"]));

object o = dt.Rows[0]["NOIDUNG"];
string s = o.ToString();
Debug.Print(s);