C#

MyStream.Buffer(()=>Observable.Merge(MyStream.Buffer(9),MyStream.Buffer(7))

public class PropertyPath<TProp> : PropertyPath
    {
        internal PropertyPath()
        {
        }
        public new TProp Value
        {
            get
            {
                var v = base.Value;
                if (v is TProp)
                    return (TProp)v;
                return default(TProp);
            }
            set { base.Value = value; }
        }
    }
    public class PropertyPath : ModelBase
    {
        public static PropertyPath<TP> Link<T, TP>(T root, Expression<Func<T, TP>> e, Action<TP> onValueChanged)
        {
            var pv = new PropertyPath<TP>();
            pv.PropertyChanged += (o, eargs) =>
            {
                if (string.IsNullOrEmpty(eargs.PropertyName) || eargs.PropertyName == "Value")
                {
                    onValueChanged(pv.Value);
                }
            };
            pv.Initialize(e);
            pv.Root = root;
            return pv;
        }
        public static PropertyPath<TP> Link<TP>(Expression<Func<TP>> e, Action<TP> onValueChanged)
        {
            var pv = new PropertyPath<TP>();
            pv.PropertyChanged += (o, eargs) =>
            {
                if (string.IsNullOrEmpty(eargs.PropertyName) || eargs.PropertyName == "Value")
                {
                    onValueChanged(pv.Value);
                }
            };
            pv.Initialize(e);
            return pv;
        }

        public static PropertyPath<TP> Create<T, TP>(T root, Expression<Func<T, TP>> e)
        {
            var pv = new PropertyPath<TP>();
            pv.Initialize(e);
            pv.Root = root;
            return pv;
        }
        public static PropertyPath<TP> Create<TP>(Expression<Func<TP>> e)
        {
            var pv = new PropertyPath<TP>();
            pv.Initialize(e);
            return pv;
        }

        internal PropertyPath()
        {
        }
        void Initialize(LambdaExpression e)
        {
            object root;
            var path = ReflectionEx.GetLambdaPath(e, out root);
            if (path.Length == 0)
                throw new ArgumentException();
            pvalues = new PropertyValue[path.Length];
            roValues = new ReadOnlyCollection<PropertyValue>(pvalues);
            for (int i = 0; i < path.Length; i++)
            {
                var meIndex = i;
                var pv = new PropertyValue(this, i, path[i]);
                pvalues[i] = pv;
            }
            Root = root;
        }

        PropertyValue[] pvalues;
        ReadOnlyCollection<PropertyValue> roValues;

        public object Root
        {
            get { return root; }
            set
            {
                if (Equals(Root, value))
                    return;
                if (value != null && !pvalues[0].Member.DeclaringType.IsInstanceOf(value))
                    throw new InvalidCastException();
                root = value;
                pvalues[0].Object = root;
                OnPropertyChanged();
            }
        }
        object root;

        public object Value
        {
            get { return pvalues[pvalues.Length - 1].Value; }
            set { pvalues[pvalues.Length - 1].Value = value; }
        }

        public ReadOnlyCollection<PropertyValue> Elements { get { return roValues; } }

        #region class PropertyValue

        public class PropertyValue
        {
            internal PropertyValue(PropertyPath path, int index, MemberInfo member)
            {
                this.index = index;
                Path = path;
                Member = member;
            }
            int index;
            public PropertyPath Path { get; private set; }
            public MemberInfo Member { get; private set; }
            public string Name { get { return Member.Name; } }

            void SetMemberValue(object value)
            {
                if (Member is FieldInfo)
                    ((FieldInfo)Member).SetValue(Object, value);
                else if (Member is PropertyInfo)
                    ((PropertyInfo)Member).SetValue(Object, value);
                else
                    throw new InvalidOperationException();
            }
            object GetMemberValue()
            {
                if (Member is FieldInfo)
                    return ((FieldInfo)Member).GetValue(Object);
                else if (Member is PropertyInfo)
                    return ((PropertyInfo)Member).GetValue(Object, null);
                else
                    throw new InvalidOperationException();
            }

            public object Object
            {
                get { return mObject; }
                internal set
                {
                    if (value == mObject)
                        return;

                    if (mObject is INotifyPropertyChanged)
                    {
                        ((INotifyPropertyChanged)mObject).PropertyChanged -= watcher;
                    }
                    mObject = value;
                    UpdateValue();
                    if (mObject is INotifyPropertyChanged)
                    {
                        watcher = WeakEvents.AddWeakHandler((INotifyPropertyChanged)mObject, this, (x, args) =>
                        {
                            if (args.PropertyName == null || args.PropertyName == x.Name)
                                x.UpdateValue();
                        });
                    }
                }
            }
            object mObject;
            PropertyChangedEventHandler watcher;

            void UpdateValue()
            {
                var v = GetMemberValue();
                if (Equals(v, Value))
                    return;
                mValue = v;
                OnValueChanged();
            }

            public object Value
            {
                get { return mValue; }
                internal set
                {
                    if (Equals(value, Value))
                        return;
                    SetMemberValue(value);
                    mValue = value;
                    OnValueChanged();
                }
            }
            object mValue;

            void OnValueChanged()
            {
                if (index == Path.Elements.Count - 1)
                    Path.OnPropertyChanged(nameof(Value));
                else
                    Path.Elements[index + 1].Object = Value;
                ValueChanged?.Invoke(this, EventArgs.Empty);
            }
            public event EventHandler ValueChanged;
        }

        #endregion
    }

1. The question implies you have no experience at all in software development. One of the most important rules is "seperation of concerns". Basically you divide a problem in smaller problems and solve them one by one. In this case, connecting database records directly to a grid is just not done.
2. The question implies you have not done any research on the subject, which also implies you're taking the easy road.
3. You have not even read this forum's guidelines[^]