►
Description
Click Here to Subscribe: http://xaf.life/35
Websites:
https://xafmarin.com/
https://xari.io
https://www.xafers.training/
http://xafersweekly.com/
Facebook Group
http://xaf.life/4g
Free XAF Support Hour
https://calendly.com/xari/free-xaf-support-hour
A
Platform
group,
we
have
already
covered
Malaysia,
Maui
avalonia
Uno
platform
webassembly,
and
there
is
a
lot
of
great
things
coming
today.
We're
gonna
be
coming
back
to
the
topic
of
data
sync
with
Entity
framework.
We
didn't
meet
up
15
days
ago
two
weeks
ago,
but
I
think
that
there
was
a
issue
with
some
that
not
everyone
will
join.
We
are
not
too
many
today,
so
this
is
great.
If
you
guys
want
to
interact,
ask
questions
and
participate.
That
would
be
amazing.
Culture
here
has
a
really
nice
presentation.
A
With
obtain
finger
cross
all
right,
so
having
said
that,
thank
you
for
joining
I.
Will
it's
gonna
start
because
that's
fair
for
everyone
who
is
here,
everyone
who
is
a
arriving
later?
We
can
join
we're
gonna
record
the
session,
and
then
you
I
can
catch
it
up
on
YouTube.
So
saying
that
okay
is
all
yours.
Thank
you
for
for
the
presentation.
If
you
want
to
introduce
yourself
for
the
person
that
watch
this
later
on,
but.
B
B
By
failing
many
many
times,
you
learn
all
the
tricks
from
the
from
the
craft
right.
So
then
we
created
the
sync
framework
for
XPO.
That
is
a
private
implementation
or
if
at
least
so
far
is
private
and
then
one
day
while
I
was
trapped
in
Mexico
for
like
one
day,
I
needed
to
travel
and
I
was
not
able
to
so
I
changed
my
flight
and
everything
and
I
was
in
the
airport
for
like
one
afternoon
like
maybe
six
hours,
so
I
sit
in
a
cafe
and
I
said.
Okay.
B
This
thing,
let's
check
if
we
can
do
this,
for
this
synchronization
framework
for
Entity,
Framework,
I,
read
all
the
source,
source
source
source
source
and
more
source
and
after
a
while
it
just
run
so
this
was
the
original
prototype
just
took
six
hours
or
something
like
that.
Then
I
use
all
the
other
parts
from
the
XPO
synchronization
framework,
and
we
put
it
together.
B
Because
there
is
more
of-
or
there
is
more
than
data
synchronization
in
general,
you
need
network
communication,
a
lot
to
be
able
to
send
and
bring
the
changes
from
other
nodes.
So,
let's
start
with
with
the
repository
now,
there
is
a
lot
of
information
there.
So
this
is
the
official
address
of
the
repo
here.
I
explain
a
little
bit
about
the
theory
that
we
use,
which
is
Delta
encoding,
that
there
are
two
different
versions
of
the
string
framework.
B
At
the
moment
the
scene
framework
itself,
which
is
actually
just
this
project,
which
is
a
set
of
contracts
and
classes
for
Delta
encoding,
is
open
source.
The
implementation
one
implementation
is
low
source,
which
is
XPO
and
one
is
open
source
which
is
Entity
framework
work.
So,
regarding
data
synchronization
here,
I
have
a
lot
of
Articles.
I've
been
writing
about
this
for
some
time
already.
B
B
Well,
the
idea
of
the
data
synchronization
or
the
Delta
encoding
is
kind
of
easy,
and
it's
based
on
this
equation,
which
to
read
it
in
a
easy
easy
way
is:
if
you
take
all
the
difference
between
all,
if
you
record
all
the
changes
between
two
stages
and
put
them
together,
you
will
get
the
last
state.
That's
basically
what
this
means
so
in
here,
for
example,
I
did
this
with
queries.
B
Basically,
you
insert
in
in
a
database
and
then
you
copy
all
those
changes
to
another
database
or
to
two
different
database
client,
a
and
Clay
B.
And
then,
if
you
execute
the
same
queries,
you
will
end
up
having
the
same
database.
That's
that's
basically
the
idea
of
this
equation.
You
can
include
any
number
of
nodes
in
there,
so
here
you
will
see
a
little
bit
more
about
the
theory
and
so
far
at
the
moment.
B
This
was
originally
compiled
for
Net,
5
and
Entity
framework
core
five,
but
it
was
trapped
within
itself
because
you
cannot
use
Net
5
on
summary
applications
and
Maui
was
not
ready
yet
so,
basically,
it
was
like
kind
of
in
between,
because
the
Technologies
were
not
ready.
So
last
week
we
moved
to
net
6,
which
is
the
long-term
support
of
the
framework
and
20
different
courses.
Also,
when
we
compile
that
when
the
tests
run
and
everything
was
fine,
we
did
a
new
version
of
moving
to
ndd
framework
7,
but
we
kept
the
target
as
net
6..
B
B
So
that
is
the
frame
or
infrastructure
that
all
the
providers
might
not
be
at
the
same
level
or
Target
in
the
same
level.
For
example,
at
one
moment,
I
know
that
this
table
is
going
to
break
while
my
still
stay
on
seven
and
then
one
will
go
to
eight
or
something
like
that,
so
we're
trying
to
keep
all
together
and
we're
trying
to
have
the
minimum
common
denominator
for
it.
B
So
here
you
can
see
the
new
packages,
all
of
them
are
available.
That's
something
also
new.
This
repo
was
public
for
a
long
time,
but
it
we
didn't
provide
any
any
new
implementation.
You
have
to
create
your
own
nuggets
or
compile
the
dlls
and
get
them
yourself.
Now.
If
you
put
bit
data
sync
in
nougat
already,
you
see
all
the
packages
that
you
can
use
in
general,
so
going
back
here
to
the
to
the
original
idea
or
anything
was
not
here.
Yes.
B
Well,
after
you,
you
check
the
packages
that
you
might
need
it's
time
to
basically
get
it
started.
I
wrote
this
based
on
the
example
that
I'm
going
to
present
today,
so
I
try
to
make
everything
as
simple
as
possible,
because
there
are
a
kind
of
I,
don't
know
if
a
lot
of
a
little
of
configuration
and
we
try
to
make
extensions
and
everything
so
it
becomes
kind
of
simple.
B
B
B
B
So
the
parts
of
a
synchronization
framework
are
kind
of
simple.
You
have
databases
you
have
Delta
storage
Deltas
are
the
little
difference
that
we're
recording
each
time.
You
make
a
query
that
alter
the
data
like
instead
of
the
delete
we
save
a
Delta
and
then
a
Delta
processor,
a
digital
processor.
Is
that
part
of
the
framework
that
receives
Deltas
from
other
promoter
clients
and
then
execute
them
in
your
local
database?
What
does
that
mean?
B
B
It
means
that
it
will
run
those
queries
in
the
local
database
in
the
idiom
or
the
language
of
the
local
database,
because
maybe
you
have
a
Delta
that
is
on
on
SQL
Server,
SQL
language,
and
then
you
want
to
do
it
to
translate
it
to
escalate
that
that
is
a
possibility.
So
we
have
the
database,
the
Delta
storage
and
the
Delta
processor,
and
then
you
have
the
the
synchronization
server,
which
is
also
a
story
in
deltas.
B
Each
client
is
talking
to
the
to
the
synchronization
server
and
sending
these
are
my
Deltas.
This
is
what
I
have
changed
and
all
the
cloud
all
the
clients
are
pulling
the
information
from
the
Deltas
on
the
syllabus.
So
they
say
like
give
me
all
the
Deltas
from
all
their
clients
that
are
not
mine
so
or
it
can
be
even
more
complex
that
you
have
several
Delta
storage,
several
Delta
processors
and
several
databases,
and
this
is
the
basic
implementation
which
most
of
the
implementations
are
on
this
side.
Basic
node
or
you
can
have
something
like
that.
B
You
have
several
applications
that
you
want
to
synchronize.
So,
regarding
how
to
use
this
on
on
our
application
for
Entity
framework
core
what
you
can
actually
do
it
little
by
little
put
it
all
the
pieces
together,
but
the
way
to
start
in
general
is
well
in
a
different
broker.
You
use
the
DB
context
right.
So
in
our
case,
we
have
a
special
DB
context
and
the
idea
behind
this
is
that
we
replace
the
internal
Services
of
the
DB
context.
B
So
here
we
have
all
the
possible
providers,
so
we
have
the
core
path,
which
is
the
services
that
we
need
to
replace,
and
then
we
replace
them
in
the
specific
parts
of
ndd
framework.
For
example,
here
we
have
the
Delta
generator
for
postgres
and
basically
when
we
ask
this
to
create
an
instance
of
the
update,
SQL
generator
and
we
represent
with
our
own,
and
it
will
be
the
same
for
each
of
the
providers.
B
We
have
create
instance
here
and
in
all
of
them
is
exactly
the
same,
so
we
create
the
parts
that
we
need
to
record
the
records
that
have
changed
by
getting
the
query
that
change,
and
then
we
create
like
this
service
that
we
replace
in
in
the
DB
context.
That's
the
idea
so
to
get
started.
It's
kind
of
simple!
You
need
to
build
your
own
service
collection
that
you
will
use
to
replace
the
internal
one
from
the
your
unique
context.
So
you
start
by
creating
an
option
builder.
B
Then
you
will
need
also
an
HTTP
client,
because
you
need
to
send
this
to
a
server.
So
your
HTTP
client
should
be
pointing
to
your
own
URL
synchronization
server
is,
then
you
need
to
register
the
Delta
generators.
Each
database
will
register
their
own
Delta
generator,
which
means
SQL
Server
will
store
Deltas
for
SQL
for
another
SQL
server,
but
if
you
want
to
generate
for
several
databases
at
the
same
time,
you
register
extra
Delta
generators
in
this
case
we're
going
to
register
the
one
for
SQL
server
and
for
SQ
light.
B
So
whenever,
whenever
we
do
a
change,
it
will
save
it
for
two
different
type
of
database.
So
then
we
create
our
collection,
service
or
service
collection.
Sorry,
and
then
we
start
doing
the
options
for
that
collection
service.
We
tell
it
that
we're
going
to
store
the
Deltas
in
sqlite,
so
we
use
sqlite
here
and
we
pass
the
connection
string,
and
here
you
can
pass
any
bodies,
entity
frame,
mode,
connection
stream
and
provider,
we're
just
telling
them.
Okay
for
Delta
storage,
you
use
this
connection
stream
and
this
database.
These
are
extension
methods.
B
So
if
you
add
poses,
for
example,
you
will
have
here
use,
postgres
and
so
on
and
so
forth.
Then,
when
we
add
the
synchronization,
we
tell
them.
Okay,
use
this
HTTP
client
to
connect
to
the
server
in
the
server.
There
might
be
multiple
Delta
storage,
as
we
saw
here
that
you
have
in
this
area.
You
have
a
Delta
storage
and
even
processors,
if
it's
needed
so
we're
telling
it
okay
go
on
you'll,
save
your
your
Delta
changes
on
this
storage.
B
You
pass
the
identity
of
the
client.
Each
client
should
have
a
unique
identity
as
well.
I,
don't
have
a
picture
for
that
so
device
a
device,
B
device,
C
computer,
a
completely
because
you
need
to
know
who
who
are
you
in
the
in
the
network
of
nodes,
because
there
is
a
moment
that
you
tell
give
me
all
the
Deltas
that
are
not
mine
that
happen
in
other
clients.
B
So
I
want
to
include
that
information
in
in
my
database
and
when
you
do
it
it's
when
that
is
when
these
equation
basically
executes,
which
means,
if
you
put
all
the
Deltas
together
in
a
specific
order,
you
will
get
this
source
of
Truth
exactly
so
here
we're
almost
done
with
this.
So
to
the
service
collection.
We
tell
it
okay
and
you're
going
to
to
the
the
infrastructure
that
you
need,
which
is
The
Entity
Framework
sqlite
infrastructure.
B
B
And
here
we
have
all
the
properties
that
we
need,
and
then
we
override
the
on
configuring
method.
So
we
can
basically
replace
all
the
services
that
we
need.
Actually,
this
is
the
magic
line
we
being
the
service
provider
with
all
our
own
specific
services,
and
then
we
tell
it.
This
is
the
line
which
means
the
magic,
these
replace
all
the
internal
services
from
The
Entity
framework
for
the
specific
databases
with
our
own,
which
in
the
ones
that
we
have
the
intercepted
changes
that
we're
going
to
do
on
the
database.
B
B
If
you
have
your
own
specific
DB
context
with
a
lot
of
crazy
other
things
and
your
own
implementation
and
so
on
and
so
forth,
what
you
need
to
do
is
basically
do
something
like
this.
You
implement
the
icing
client
notes
and
then
at
one
moment
you
need
to
pass
the
service
provider
that
we
created
before
in
this
part
and
then
Delta,
processor,
okay,
this
is
the
processor.
B
B
B
You
do
your
operations,
you
retrieve
the
data,
you
show
it,
you
put
it
in
a
list
order
or
you
do
the
sync
operations,
but
it's
good
that
you
put
this
in
and
using
context.
So,
every
time
that
you
going
to
execute
something,
you
have
a
fresh
copy
of
the
context
like
this
will
be
like
something
to
get
a
new
object
space
in
itself.
B
So
for
one
reason,
sometimes
in
mobile
devices.
The
HTTP
client
that
we
created
here
at
the
beginning
get
skilled,
so
you're
still
recording
the
Deltas,
but
sometimes
when
you
try
to
send
them,
it
looks
like
it's
sending,
but
there
was
no
communication
to
the
server.
So
that's
a
problem
that
I
saw
happening
on
on
Maui
in
Maui
for
Android.
B
B
We
will
not
send
the
information
to
the
server
and
now
regarding
the
implementation
of
the
server,
is
kind
of
simple.
If
you
put
an
asp.net
core
web
API
and
you
pass,
you
need
to
register
a
service,
a
Singleton
Services,
a
Singleton
Services,
sorry,
which
is
a
server
node
in
here,
we're
passing
the
most
easy
implementation,
which
is
a
Delta
store
and
memory
data
store.
B
So
the
teacher
will
be
saving
memory,
they
will
be
alive
while
they
celebrated
is
running
and
then
the
the
clients
can
talk
to
the
server
and
exchange
information
through
the
celebrity
memory.
But
this
it
means
we
can
replace
this
for
something
like
a
Delta
store
for
Entity
framework
or
XPO
I
mean
in
some
cases
some
part
some
part
of
the
framework.
As
long
as
you
implement
the
interface,
they
are
interchangeable,
you
can
store
Deltas
on
XPO
and
even
those
are
generated
by
in
the
different
mode
or
the
other
way
around.
B
So
that's
why
we
love
this
interface
in
methodology
of
solid
of
the
solid
design
pattern
so
continuing
on
this,
so
you
need
to
implement
a
controller
with
two
methods:
push
and
phage.
Why
not?
Pull
because
pool
is
to
fetch,
but
just
to
process
the
Deltas
on
the
client
side,
so
everything
is
push
and
page.
B
B
We
had
a
pull
request
from
one
User
make
some
modifications
to
make
a
more
complex
schema
of
synchronization,
and
we
were
talking
about
about
how
how
we
can
use
different
nodes
in
the
server
and
what
do
you
need
to
send
to
to
the
store?
Okay,
I
want
to
store
in
the
Delta
storage
one.
This
is
two
and
so
on
and
so
forth.
So,
let's
see
where
were
we
let's
go
back
to
the.
B
Okay,
let's
go
down
so
in
here.
Basically,
we
Implement
these
two
operations
and
the
the
Network
infrastructure
of
of
the
synchronization
framework
is
already
trying
to
do.
Http
pause
on
HTTP
get
for
these
operations.
So
what
we
were
talking
about
that
about
in
about
that
ticket
that
I
show
you
is
that
sometimes
you
might
need
extra
operations.
For
example,
what
will
happen
if
everyone
is
synchronizing
data?
Everything,
Is,
Beautiful,
you've
been
synchronizing
data
for
one
month,
but
you
need
to
include
a
new
client.
B
B
This
is
the
basic
implementation
and
we
will
Implement
whatever
it
gets
requested
that
becomes
more
popular,
but
that
that
idea
of
Christ
of
technology
in
the
database
from
from
a
point
in
time
or
a
stage
like
you
was
crash,
and
then
you
need
to
record
so
that
it's
a
good
idea.
We
have
them
in.
We
have
some
specific
implementations
of
that
in
in
the
the
XPO
version
of
the
same
framework
for
some
customers.
So
it's
a
good
idea:
I'll
try
to
make
them
generic
and
maybe
include
them
in
the
in
the
future.
B
Let's
see
how
this
goes
in
general
and
that's
basically,
it
I
think
that
we
are
ready
for
the
for
the
example
of
to
make
a
something
running.
So
all
the
code
that
I
show
in
here
I
got
from
this
example
that
they
have
in
here
so
here,
I'm
running
already
a
server
soft
application
and
a
mouse
application
for
the
server
I'm,
using
this
beautiful
future
or
feature
of
Visual
Studio,
the
newest
version.
It
comes
with
something
called
two
nails,
so
we
have
an
http.
B
B
B
B
B
B
B
B
B
B
B
B
With
desktop
that's
the
idea
of
of
of
more
most
of
the
synchronization
cases,
so
let's
reveal
this.
This
will
take
a
while.
So
while
we
wait,
if
someone
has
a
a
question,
you
can
put
it
on
the
chat
and
it's
a
good
time
to
discuss
anything
because
Maui
compilations
they
do
take
a
while,
especially
when
you
change
targets.
B
B
A
B
B
A
B
B
I
mean
the
thing
is
that
they
come
already
with
the
studio
and
one
less
thing
to
to
use.
Also,
if
you're
using
the
preview
of
the
studio
and
distinction
doesn't
work,
sometimes
you
have
to
turn
it
on
manually,
so
well,
we're
still
compiling
the
beauty
of
multi-targeting
and
the
computer
is
still
a
little
bit
on
fire.
B
So
what
else
can
I
show
you
here?
Well,
let
me
show
you
the
xaf
part
for
the
people
who
is
xaf
user,
so
in
xcf
it
was
hard
to
include
our
own
flow
actually
by
including
order
first
like
or
a
specific
context,
which
is
the
same
frame
or
DB
context.
We
kind
of
break
the
flow
of
xaf
a
little
bit,
so
we
basically
did
all
the
steps
I
showed
you
before,
but
we
put
it
in
the
Constructor
and
then
we
operate
the
unconfigure.
B
We
just
had
to
add
a
few
more
lines
to
make
it
work
with
stuff,
but
then
it
basically
work
I
need
to
contact
the
people
from
developer
Express
to
tell
them.
Okay,
I
need
to
change
the
context
in
a
specific
way.
How
can
I
do
it
without
breaking
the
flow,
because,
right
now,
when
I
put
this
stuff,
I
kind
of
don't
like
it,
but
anyway
it's
working
and
it's
the
first
iteration.
So
sometimes
you
have
to
go
to
those
moments
that
you
break
your
stuff.
Okay.
B
B
B
B
B
B
B
B
The
communication
diet-
that's
something
that
happens
from
time
to
time,
but
in
the
end
this
is
kind
of
the
idea.
I
think
that
I
have
some
problems
with
the
VPN
and
everything,
but
as
you
can
see,
we
were
able
to
synchronize
one
of
the
records.
You
can
repeat
this
operation
forever.
Basically,
and
what
happens
is
that
you
just
need
to
make
sure
that
you
use
the
context
and
you
have
the
the
use
of
fresh
context
all
the
time,
and
then
you
have
the
HTTP
communication
working.
B
So
that's
basically
it
for
this
example.
Usually
in
this
multi
project
example
is
usually
is
it
that
something
breaks
on
the
demonstration
like
it
did
right
now,
because
we're
only
in
Decline
the
cerebral
and
another
client
in
the
same
computer.
But
if
you
want
to
get
a
hold
of
this
and
see
how
it
works,
I
strongly
suggest
you
to
go
to
the
repository.
You
download
the
code,
you
compile
it
and
you
go
to
the
integration
test.
B
There
is
easier
to
see
how
it
works.
So
in
the
test
you
go
to
the
Entity
framework
test,
and
then
you
run
this
one
all
database
tests.
You
just
need
to
replace
your
connections.
This
thing
at
the
beginning.
This
is
a
synchronization
made
completely
by
code,
so
you
create
several
nodes:
each
node
Implement
a
different
database.
B
Then
you
create
the
Excel
expression
for
all
the
databases
you
create
all
the
contexts
and
then
you'll
start
interchanging
data
between
all
the
all
the
nodes.
So
and
then
you
count
that
the
Deltas
are
exactly
the
same.
The
records
are
exactly
the
same.
So
this
is
a
really
beautiful
example,
because
you
can
see
it
all
work
in
a
in
the
same
picture
without
having
to
go
click
here,
click
there
pull
push
and
do
all
the
stuff,
that's
more
for
a
real
scenario.
B
So
that's
basically
it
for
this
demonstration.
If
you
have
any
questions
regarding,
you
can
actually
send
me
an
email
write
it
here
or
just
put
something
in
the
put
an
issue
on
the
on
the
repository
and
since
demonstration
kind
of
broke
person
in
some
cases.
This
is
how
it
should
look
like
exactly
like
when
well,
you
know
when
no
one
is
watching.
Everything
is
working
fine,
but
when,
when
you
have
to
do
it
in
front
of
people,
it
breaks
so
see
here
we're
pushing
we're
pulling
we're
editing.
B
A
That
would
be.
That
would
be
all
right
thanks
everyone
for
coming
and
feel
free
to
get
the
report
unloaded
play
with
it
test
with
it.
Give
us
feedback
I
think
that
there
is
a
lot
of
use
case
for
this
same
framework.
We
have
been
used,
the
XPO,
that
it
was
the
the
actual
where
the
idea
was
born
from
and
with
really
good
results,
so
a
go
crazy
with
it
give
us
feedback.
Let
us
know
how
it
goes.
A
If
you
can
see
you
can
synchronize
across
database
across
different
platforms
everywhere,
the
net
is
running
with
enter
different
record,
so
copper,
great
things,
coming
on
a
talk,
a
lot
of
things.
They
talk
about
pleasure
and
open
AI
I
talk
about
a
CSS
for
the
place
of
developers,
so
see
you
guys
next
month
and
thank
you
for
joining
right
right.