►
From YouTube: PnP Webcast - Introduction to Microsoft Graph .NET SDK
Description
In this PnP Web Cast we concentrated on Microsoft Graph or more specifically covering how the .NET SDK for Microsoft Graph can be used in your customizations. .NET SDK for Microsoft Graph is great tool for simplifying the development experience when you take advance of Graph APIs. It provides easy to use and fluent access on information exposed within the Microsoft Graph APIs.
Presentation covers following topics:
- Introduction to Microsoft Graph API
- Introduction to .NET SDK for Microsoft Graph
- Insights on request model, query model, resource management and for exception handling
This web cast included three specific demos
- Playing with the Microsoft Graph API - Graph explorer and available resources
- "Hello world" with Microsoft Graph .NET SDK
- Request and Query model for with .NET SDK
Sample used in the web cast is available from the Office 365 Dev Patterns and Practices code gallery at https://github.com/OfficeDev/PnP/tree/dev/Samples.
Web cast presenters: Paolo Pialorsi, Vesa Juvonen
Paolo works in Piasys.com and is one of the external members in the SharePoint / Office 365 Dev PnP Core team.
Presentation used in this web cast is available from http://docs.com/OfficeDevPnP.
Additional resources
- Microsoft Graph documentation - Official landing page of - Microsoft Graph - http://graph.microsoft.io/en-us/
Graph Explorer - Great tool for seeing the API in practice - https://graph.microsoft.io/en-us/graph-explorer
- Microsoft Graph GitHub organization - GitHub location for Graph related information - https://github.com/microsoftgraph
- Microsoft Client Library (SDK) for .NET - .NET SDK for Microsoft Graph - https://github.com/microsoftgraph/msgraph-sdk-dotnet
- Microsoft Graph SDK Code Generator - Tool used to update SDK code as needed with updates in the grap metadata API - https://github.com/microsoftgraph/MSGraph-SDK-Code-Generator
- Office 365 Dev PnP Sample on .NET SDK usage - https://github.com/OfficeDev/PnP/tree/dev/Samples/MicrosoftGraph.Office365.DotNetSDK
Thanks for your interest on the PnP initiative.
If you have any feedback or comments related on this web cast, please use the Office 365 network at http://network.office.com. Thx for your interest advance.
A
Welcome
everybody.
This
is
office
365,
but
in
some
practices
webcast
and
this
time
we're
gonna
talk
about
Microsoft,
craf,
SDK
and
more
specifically,
for
the.net
managed
code.
So
we
kind
of
have
a
look
on
the
Microsoft
craft
and
then
we're
gonna
have
a
look
on
the
on
the.net
SDK
for
Microsoft
graph,
and
what
does
it
actually
provide?
How
do
you
use
that,
and
what
are
the
kind
of
a
small
coaches
around
and
with
me
today
is
Paula
Pelosi
and
Paula
is
gonna
lead
the
presentation
today,
Sao
Paulo
will
do
a
quick
introductions.
A
B
A
Good
excellent
Sao
Paulo
is
gonna,
lead
the
presentation
and
I'll
be
asking
questions
every
now
and
then
here
and
there
interrupting
him.
While
we
can
move
along
within
the
things
just
before
we
actually
get
started
just
to
remind
everybody.
The
one
address
you
want
to
remember:
HTTP
AKMs
office,
def,
B&B
and
you'll,
learn
to
the
PNP
site
office,
365,
developer
patterns
and
practices
contains
guidance
for
SharePoint
framework
for
SharePoint
add-ins
for
Microsoft
graph
of
a
365
api's
and
all
of
them.
So
there's
a
lot
of
code.
Examples
there's
a
lot
of
guidance
document
ations.
A
We
do
a
monthly
community
course
where
we
go
through
what
has
happening
within
the
previous
month,
and
we
do
have
actually
a
few
case.
Studies
as
well,
but
I
think
the
only
thing
to
remember
is
taking
as
a
kms
office,
def
B&B,
so
go
and
check
it
out.
We'll
have
all
the
links
to
all
of
these
webcasts
and
a
lot
of
other
stuff
there
as
well.
But
let's
get
on
going
on
today's
session
around
the
craft
and
Paul
is
going
to
lead
today
and,
like
mentioned
I'm
gonna
interrupt
him.
B
Thank
you
and,
first
of
all,
let's
start
from
the
list
of
topics
we
will
cover.
We
will
start
adding
a
look
at
the
Microsoft
graph,
API
by
themselves,
a
very
short
preview
and
overview
of
the
graph
API,
and
then
we
will
dig
into
the
graph
SDK
and
especially
the
reference
decay
for
dotnet
developers,
sharing
with
you
about
information
about
the
architecture
of
the
graphics
decay,
as
well
as
showing
you
some
demos
about
how
to
use
it
in
order
to
become
powerful
and
rich
full
in
your
own
solution,
consuming
the
graph
API.
B
And
so,
let's
start
with
the
graph
API.
Firstly,
so
the
prophecy
I
it
is
a
new
set
of
API
is
provided
by
Mike.
So
since
a
few
months
ago,
which
allows
us
to
consume
most
of
the
services
right
now
provided
by
the
office,
365
ecosystem
using
a
unique
set
of
API,
send
a
unique
endpoint,
a
unified
endpoint,
so
that,
from
a
developer
perspective,
it
is
much
more
easier
to
do
a
unique
and
shake
to
get
a
unique
access.
B
Token,
from
an
open
authorization
perspective
and
to
consume
the
full
set
of
services
provided
with
a
unique
developer
experience.
So
as
long
as
you
know
how
to
consume
a
set
of
REST
API
using
open
authorization
and
as
long
as
you
have
a
development
platform
which
allows
you
to
make
HTTP
requests,
including
the
open
authorization.
There
are
token
in
the
request.
B
Headers,
you
will
be
ready
to
consume
services
which
allow
you
to
interact
with
exchange
online
with
onedrive
for
business
with
OneNote
and
all
of
the
other
services
that
are
provided
through
the
office
35
offering,
and
not
only
those
services
which
are
related
to
office
85,
but
as
a
visa
can
tell
us
pretty
soon
and
many
other
services
related
to
the
entire
Mike's
of
family
right.
There's
absolutely.
A
B
So
you
can
interact
with
your
documents
in
onedrive
for
business,
for
example,
with
your
mailboxes,
with
your
calendar
and
contacts
like
people,
you
can
do
searches,
you
can
consume
the
office
graph,
which
is
still
there
related
to
the
office
of
6-5
family
and
to
the
experience
to
the
relationship
that
you
can
have
between
contents
and
users
in
the
office,
365
ecosystem
of
services.
You
can
interact
with
the
office,
these
five
groups,
not
books,
videos
and
many
other
capabilities
provided
by
office
365,
and
you
can
do
that
from
whatever
device
and
platform
you
like.
B
So
you
can
use
an
iOS
platform,
an
Android
platform,
a
Windows
which
can
be
a
Windows
Phone
or
a
unified
Windows
platform,
and
the
overall
goal
of
the
graph
API
is
to
give
you
a
unique
approach,
an
open
approach
which
can
be
consistent
across
multiple
services
in
multiple
platforms,
to
reach
your
goals
and
to
consume
all
of
these
bbi's
and
well
from
a
developer
perspective.
So
you
have
to
consume
the
graph
that
my
talk
on
URL,
providing
through
the
path
of
the
URL.
B
What
is
your
target
and
when
I
say
target
I
mean
the
target
version
of
the
API
that
you
wanna
consume
and
any
of
the
entities
or
entity
sets
that
are
available
through
the
API
so
that
you
will
be
able
to
consume
their
properties
to
invoke
operations
related
to
any
specific
entity?
And
all
of
the
capabilities
that
you
have
through
the
api's
are
well
documented
in
an
information
technology
way,
let
me
say,
through
a
set
of
metadata
descriptors,
which
are
available
under
the
dollar
metadata
URL
related
to
any
of
these
specific
versions.
B
You
wanna
consume
right
now
at
the
time
of
recording
this
work,
that
we
have
the
version
1.0
as
the
release
to
market
version
of
the
graph
API,
and
we
also
add
the
beta
version,
which
is
improving
on
in
daily
basis,
which
is
under
the
beta
relative
URL
of
the
graph
dot
Mac,
so
calm
URL.
And
what,
if
you
invoke
any
of
those
two
URLs
putting
the
dollar
metadata
in
point,
you
will
get
back
an
XML
descriptor
which
will
give
you
a
bunch
of
information
about
what
are
the
entities?
B
A
B
From
most
of
the
common
platform,
you
have
like
a
USB
HP,
nodejs,
Windows,
Phone
or
universal
Windows,
app
and
so
on,
and,
as
you
can
see
there
already,
some
of
these
platforms
are
ready
to
go
and
some
other
still
under
construction
like,
for
example,
the
nodejs,
which
will
be
come
pretty
soon.
If
you
stay
tuned,
if
you
monitor
this
website,
you
will
be
able
to
see
what
is
available
and
what
is
ready
to
go
for
consuming
the
API,
as
well
as
using
the
changelog
link.
A
B
True
totally
agree:
if
you
want
to
approach
the
recipe
I
from
a
developer
perspective,
let
me
say
from
a
low-level
perspective,
more
or
less
low
level.
You
can
of
course,
consume
the
dollar
metadata
endpoint,
which
I'm
showing
you
just
for
the
sake
of
completeness,
but
we
will
not
go
through
all
of
the
XML
elements
in
this
file.
I,
just
wanna,
let
you
know-
and
let
you
see
that
inside
this
file,
you
can
find
a
bunch
of
descriptors
of
all
of
the
entities
available
in
the
graph
API.
B
So,
for
example,
if
I
search
for
the
user
entity,
I
can
see
that
we
have
an
entity
type,
which
is
an
XML
element
which
will
define
how
a
user
is
made.
So
we
can
see
that
the
user
is
a
display
name,
a
given
name,
email
address
and
stuff
like
that.
And,
moreover,
if
we
search
for
graph
service,
we
see
that
we
have
an
entity
container
element
which
the
finder
is
an
entry
point
called
graph
service
which
will
give
us
access
to
a
bunch
of
information.
B
Like
the
office
thesis
fight
group,
the
devices
in
our
tenant,
the
users
define
in
our
tenant,
as
well
as
my
currently
logged
in
users,
which
is
called
me
and
all
of
this
stuff
can
be
consumed
using
the
REST
API
and
using
the
open
data
protocol
and
the
open
authorization
protocol
from
an
authorization
perspective.
Of
course,
this
kind
of
XML
document
target
platforms
which
can
automatically
array
this
kind
of
fuss.
B
We
will
not
do
that
manually,
but
we
have,
in
the
micrograph
website
a
graph
Explorer
tool
which
is
really
powerful
just
to
play
with
the
api's,
without
adding
to
write
any
real
line
of
code,
so
just
to
show
you
how
it
works.
I
am
already
logged
in
with
my
account
in
my
development
channel,
as
you
can
see
from
here
and
I
can
consume
the
graph
API,
for
example,
to
create
myself
to
query
the
object,
which
represents
myself.
B
If
I
prefer
the
me
entity
inside
the
root
URL
of
the
v1
and
graph
and
pointer,
you
can
see.
The
information
related
to
my
current
user
or
I
can
create
a
list
of
all
the
users
that
I
have
in
my
tenant
and
I.
Will
get
back
an
array,
a
JSON
representation
of
an
array
of
objects
which
will
be
all
of
the
users
in
my
tenant
and
so
on
so
forth.
A
Now,
Paulo
and
that
one
actually
can
assure
also
the
bed
endpoint
for
me,
because
we
saw
that
the
me
within
the
v
1.0
was
relatively
small,
but
this
actually
shows
how
things
are
evolving
so
in
the
beta
endpoint
as
an
example,
there's
a
lot
of
additional
capabilities
and
a
lot
of
additional
attributes
available
for
the
user.
So
this
is
the
user
attributes
and
a
beta
endpoint
and
then
the
v1
1.0
is
a
slightly
more
simplified
and
anything
yeah.
B
B
B
B
First
of
all,
and
the
probably
the
main
information
is
that
the
graph
is
decay
is
an
open
source
sdk.
In
fact,
the
graph
SDK
is
available
on
github
on
a
dedicated
repository
in
which
you
can
find
all
of
the
source
code
so
that
you
can
understand
how
it
works,
and
you
can
eventually
use
it
and
extend
it
if
you
like,
you
will
just
need
to
fork
it
on
your
own
environment.
B
B
So,
for
example,
we
saw
in
the
previous
demo
that
we
have
the
user
entity
defined
in
the
dollar
metadata
descriptors
and
we
have
the
meet
property
of
the
graph
service
entity.
Well,
the
auto
generated
code
will
create
a
user
type
which
will
represent
from
a
domain
model
perspective.
The
idea
of
a
user
will
give
us
a
graph
service
client
object
with
a
me
property
which
will
give
us
access
to
the
currently
logged
in
users
and
so
on
so
forth.
B
Moreover,
it
has
been
a
synchronous
programming
model
and
it
provides
in
a
synchronous
programming
model
so
that
you
can
use
it
from
whatever
kind
of
application
and
you
can
benefit
from
the
a
synchronous
model
to
have
much
more
available
and
responsive
applications,
not
responsive
from
a
responsiveness
perspective
from
the
mobile
perspective,
but
I
mean
with
a
more
smart
behavior
when
consumed
by
the
end-user,
because
they
will
be
a
synchronous
applications.
So
how
can
you
use
the
graph
SDK
for
dotnet
or
in
general?
B
Well,
first
of
all,
you
have
to
install
the
graph
SDK,
which
is
also
made
available
as
a
new
gate
package.
So
if
you
want
to
dig
into
the
source
code,
you
can
go
home
github.
You
can
fork
it,
you
can
play
with
the
source
code,
but
if
you
want
to
simply
use
it,
you
can
simply
create
a
vicious
to
the
project.
You
can
access
the
new
gate,
browser
and
search
for
the
maxigrove
package.
B
You
will
have
to
register
your
application
so
that
it
will
be
allowed
for
that
application
to
consume
the
graph
API
so
and
right
now,
at
the
time
of
recording,
we
have
at
least
two
options
to
register
one
application.
The
first
one
is
probably
the
one
known
one
which
is
based
on
Asia
the
directory,
so
you
will
have
to
go
to
the
management
portal
of
it
sure
you
can.
B
If
you
want
to
use
the
first
option,
is
your
Active
Directory
you
will
have
to
consume
and
to
implement
the
authentication
logic
using
the
ADL,
so
Microsoft
Azure,
Active
Directory
authentication
library,
which
is
now
in
version
3.0.
If
you
want
to
consume
the
new
v2
authentication
point,
you
will
have
to
leverage
the
MSA
L
Mike
certification
library,
which
is
still
in
preview
right
now.
So
again
you
shouldn't
use
it
in
production,
but
you
can
start
playing
with
it
and
using
MSA
L.
You
will
have
a
new
approach
which
allow
you
to
use.
B
A
B
It's
really
cooling,
much
more
free,
so
you,
you
are
not
tied
to
define
what
are
the
permission
when
you
declare
the
application,
but
you
can
ask
to
the
end-users
a
consent
to
have
those
specific
permission
that
you
wanna
have
when
you
want
to
consume
the
API
yep.
So
you
create
your
project.
You
installed
an
you
get
package.
B
You
register
your
application
in
whatever
registration
platform
you
like,
and
you
prepare
the
authentication
code,
which
will
be
a
delegate
that
has
to
be
provided
to
the
graph
service
client
and
then
you
are
ready
to
go
you're
ready
to
consume
the
graph
API.
So,
let's
see,
let's
see
it
in
action
using
a
bunch
of
code
in
Visual,
Studio
I
will
go
to
the
visual
studio
project,
I
already
created
that
just
for
the
sake
of
having
a
sample
ready
to
go
and
which
will
be
available
within
the
next
master
matter
of
TMP
in
the
pnp
repo.
B
B
We
use
the
public
client
application,
which
is
one
of
the
two
types
available
in
MS
al
to
do
authentication
against
a
unified
endpoint,
and
this
one
is
the
one
used
whenever
you
want
to
access
the
target
services
using
the
client
ID
of
a
specific
application
and
consuming
the
targets
framework
of
a
vis.
So
here
I
will
have
to
get
the
client
ID
an
access
token,
with
the
legation
for
my
current
user
and
a
public
client
application
object.
B
I
have
to
create
an
instance
of
the
graph
service
client
type,
which
is
provided
by
the
Microsoft
graph
namespace,
which
is
the
main
one
for
the
graph
is
the
key
for
not
nectar
and,
as
you
can
see,
the
constructor
of
this
type
when
I
have
a
delegate
authentication
provider
which
internally
will
have
to
implement
the
al
dente'
keishon
logic.
Here.
I
simply
declare
that
I
wanna
acquire
a
token
a
synchronously
for
a
specific
set,
a
specific
scope
of
permissions
and
the
permissions
which
are
available
in
this
array
of
strings
are
defined
under
the
graph
dot.
B
Microdot
IO
in
the
documentation
and
just
after
death
I
get
back
an
access
token,
which
I
can
provide
as
a
better
how
to
indication
header
or
authorization
error.
Sorry
in
the
HTTP
request,
so
starting
from
here
I
will
have
a
craft
client
object
which
I
can
use,
for
example,
to
query
the
me
property
which
will
represent
from
a
graphical
perspective
the
current
user.
But
if
you
think
about
the
gravity
is
the
graph
API
is
are
provided
to
us
as
a
set
of
rest
and
points.
So
through
the
graph
client
object.
B
I
will
access
the
me
a
property
which
I
will
have
to
request,
for
so
I
will
have
to
make
an
HTTP
request
for
the
main
object
and
I
will
have
to
declare
what
I
wanna
do
with
the
need
object.
So,
for
example,
here
I
wanna
get
the
meat
object,
so
myself
I
want
to
select
the
display
name
property.
Of
course,
here
I
have
a
typo
just
to
test
what
happens
in
case
of
any
issue.
So
I
will
request.
B
The
display
name
of
myself
and
I
will
do
a
get
an
HTTP
GET
in
a
synchronous
for
that
specific
HTTP
request.
So,
under
the
cover,
what
is
happening
is
that
the
graph
SDK
provides
us
to
provide
us
a
set
of
methods
and
interfaces
which
are
auto-generated
mainly
auto-generated
use
the
VIPRE,
which
will
construct
under
the
cover
of
this
method,
the
HTTP
request
that
we
wanna
make.
B
So
let's
go
just
for
a
while
to
the
graph
SDK
source
code,
which
we
have
in
another
project
which
I
fought
from
the
github
open
source
project,
and
here
I
have
the
graph
service,
client
type
and,
if
I
scroll
a
little
bit
down
or
if
I
search
for
the
MIT
property.
You
can
see
that
the
me
property
is
a
is
a
property
of
type
I
user
request
builder.
But
if
I
go
to
see
what
is
the
definition
of
this
requesting
the
object?
B
B
In
fact,
if
I
go
how
it
is
define
and
how
it
is
implemented,
we
can
see
that
here
we
have
some
HTTP
requests
which
are
built
inside
these
methods,
which
will
simply
create
for
us
any
kind
of
HTTP
requests,
get
put
post
whatever,
providing
the
specific
content
type
of
the
request
or
of
the
response
and
using
the
low-level
primitives
provided
by
dotnet
framework
to
consume
over
HTTP
and
HTTPS.
The
target
API
has
so.
A
B
Is
totally
generated
for
you,
but
it
is
really
nice
to
see
that
they
hide
all
of
the
complexities
of
consuming
the
rest
base
and
HTTP
based
requests,
and
we
will
simply
need
to
invoke
through
a
fluent
API
a
set
of
objects
which
will
give
us
access
to
all
of
the
properties.
All
of
the
metadata
of
the
entity
that
we
wanna
consume.
B
Yeah,
just
to
do
a
little
bit
more
inside
the
SDK
works,
so
we
saw
we
have
a
request
model
which
will
use
a
set
of
auto-generated
request.
Builder
types,
which
will
be
the
high
aesthetics
request
builder,
where
every
request
builder
will
create,
will
build
literally
a
request
object
which
will,
under
the
cover,
implement
the
real
HTTP
request
for
us.
B
In
fact,
when
I
said
craft
client,
not
me
dot
request,
I
access
it
and
access
to
the
request,
object,
which
will
be
enabled
and
which
will
create
for
me
and
for
us,
the
open
data
protocol
request
to
consume
a
user
object,
which
will
be
my
currently
logged
in
user
and
when
I
use
the
get
a
sink
method,
I,
simply
fire.
The
HTTP
GET
request
against
the
target
endpoint,
which
is
what
happens
under
the
cover
of
the
getter
sinker.
B
Whenever
we
query
the
entities
provided
by
the
graph
API
through
the
SDK,
we
can
use
a
pairing
model
which
simply
replicate
the
behavior
and
the
capabilities
of
the
open
data
protocol,
which
is
provided
by
the
graph
SDK.
In
fact,
for
example,
in
the
open
data
protocol,
we
have
the
capability
to
provide,
through
the
URL
query,
string
parameters
of
the
requests
that
we
make.
B
So
if
from
an
open
data
protocol
perspective,
we
use
the
dollar
select
argument
in
the
questing
in
the
SDK,
we
have
the
Select
method
if
we
use
the
dollar
fee
after
we
have
the
filter
method,
and
so
on
so
forth,
pretty
easy
to
understand.
If
you
know
how
the
open
data
protocol
works-
and
we
will
show
you
pretty
soon
in
another
demo,
how
these
methods
work.
B
Moreover,
there
is
also
out-of-the-box
support
for
paging,
because
let's
say
you
wanna
query
the
users
you
have
in
your
tenant,
but
most
likely
those
users
will
be
hundreds
or
thousands
or
hundreds
of
thousands
of
users.
It
would
make
any
any
sense
to
make
a
unique
request
and
download
thousands
or
hundreds
of
thousands
of
users
through
pressed
through
a
JSON
civilization
of
those
array
of
users.
Of
course,
it
is
much
more
wise
to
just
request
pages
of
objects
and
to
go
through
all
of
the
pages.
B
As
long
as
you
need
to
browse
all
of
the
entities
out
of
the
box,
the
open
data
protocol
and
the
graph
API
is
paging
for
us.
So
whenever
we
make
a
request
with
whatever
platform
we
use,
we
will
be
able
to
get
pages
of
entities
and
if
you
want
using
the
SDK,
you
have
some
high
level
support
again
to
hide
the
black
cities
of
doing
paging
and
to
simply
benefit
of
the
capability
to
do
paging
across
all
of
the
entities.
B
So
let
me
move
to
one
more
demo
to
show
you
how
the
request
model
works
and
how
the
query
model
works.
So
let
me
go
back
to
visual
studio
now.
Let
me
show
you
one
more
or
some
more
examples,
still
using
the
graph
life
and
still
using
the
a
synchronous
development
model.
As
you
can
see,
we
can,
for
example,
access
the
collection
of
all
of
the
users
we
have
in
our
tank.
B
We
can
use
the
request
builder
to
build
a
request,
object
which
will
prepare
under
the
cover
the
HTTP
request,
which
will
be
able
to
select
only
those
properties
of
the
user
entities
that
we
want
to
retrieve
like
the
display
name,
the
user,
principal
name
and
email
notice.
That
year
we
have
to
know
what
are
the
product
is
available.
So
we
need
to
have
some
knowledge
about
the
graph
API
and
by
themselves.
Even
if
you
are
in
SDK
and.
A
B
The
same
happens
if
you
want
to
select
the
user,
for
example,
doing
the
or
appliance
some
kind
of
filtering
so
again,
I
get
the
client.
The
service
client
object.
I
get
the
collection
of
users
I,
make
a
request,
object,
I
select.
What
are
the
properties
that
I
wanna?
Add
flavor
and
I
apply
a
filter
which
has
to
be
provided
using
the
open
data
filtering
syntax.
A
Few
kind
of
a
comments
or
birthday:
it's
pretty
amazing,
to
say
that
it's
a
single
line
of
code
getting
all
of
that
information
and
you're,
able
to
kind
of
a
fluently
go
through
the
craft
and
the
properties,
and
all
of
that.
What's
a
super
core
now.
The
other
thing
which
is
actually
kind
of
noticeable
here
is
that
when
you're
querying
those
users
you're
kidding
only
10
users
right
yeah.
B
B
Element
in
my
example
are
the
first
five
elements
skipping
the
first
time
elements,
but
you
can
even
leverage
the
paging
capabilities,
as
we
told
you
a
few
minutes
ago,
and
in
fact
here
is
an
example
about
how
to
do
paging
against
the
collection
of
users
so
that
you
can
go
through
all
of
the
users
and
not
only
through
those
provided
by
the
first
page,
for
example,
here
I
access
again
and
one
more
time
in
the
collection,
all
users
I
make
a
request.
Through
the
request.
B
Builder
I
select
the
properties
and
I
get
a
synchronously,
the
first
page
of
the
result,
which
is
always
the
default.
You
cannot
get
the
full
set
of
elements.
You
will
simply
have
one
page
by
one
all
of
the
results.
So
what
is
really
powerful
from
the
design
perspective
of
the
graph
is
decay
for.net
and
the
graph
is
the
same
or
in
general.
Is
that
when
you
make
a
request,
you
will
get
back
an
object
as
you
can
see,
which
is
of
type.
B
Now
let
me
go
back
to
this
light
deck
just
to
share
with
you
some
few
more
information
about
not
only
I'll
to
query,
but
also
about
how
to
manage
entities
that
you
have
through
the
graph
API
and
through
the
SDK.
So,
for
example,
we
saw
that
we
can
consume
the
collection
of
users,
good
okay,
but
what?
If
I
want
to
add
a
new
user
or
what?
If
I
wanna,
create
a
new
of
this
versus
five
group
or
if
I,
want
to
upload
a
document
in
a
document
library
or
in
onedrive
for
business.
B
But
of
course
we
can
do
that
and
whenever
we
are
managing
a
collection
of
entities,
if
that
collection
of
entities
can
be
updated,
which
means
provide
the
capabilities
to
be
updated
and
the
current
user
has
proper
permissions
or
the
current
application
has
proper
permissions
to
do
that
because,
of
course,
whatever
you
do
has
to
have
proper
permission
to
be
done.
But
if
we
are
in
the
right
context,
so
with
good
permission
and
targeting
the
collection
which,
which
is
maintainable,
you
can
use
methods
like
add
a
sync
up.
B
We
simply
have
to
add
an
object
as
synchronously
to
a
collection
and
under
the
cover
it
will
be
the
SDK
to
make
the
HTTP
POST
request
serializing,
using,
for
example,
the
jesus
analyzing,
the
new,
a
sterilizer,
the
user
object
that
we
wanna
add
to
the
collection
of
users
and
again
this
is
really
really
powerful
from
a
Productivity
and
from
a
developer
perspective
and
what?
If,
while
doing
any
operation
like
request
or
an
update
or
adding
a
user?
An
exception
happened.
Well.
B
One
really
interesting
error,
type
and
error
code
is
the
one
related
to
throttling
issues.
In
fact,
if
we
consume
a
set
of
services
which
are
provided
on
a
cloud
platform
by
a
cloud
platform,
of
course,
it
could
happen
that,
because
of
some
throttling
rules
that
avoid
to
overstressed
the
server
platform
which
could
be
throttled.
B
A
B
But
luckily
and
right
now,
since
we
have
these
new
SDK,
we
can
do
it
at
the
high
level
without
having
to
dig
into
the
details
of
the
open
data
and
of
the
HTTP
protocols.
I.
Think
that
that's
all
for
these
technical
coverage
of
the
graph
SDK
and
basically
probably
we
want
to
remind
some
of
the
URLs
useful
URL
to
the
people
attending
this
webcast.
Yes,.
A
So
this
is
a
set
of
links,
the
kind
of
a
collection
of
resources,
what
we
have
for
the
office,
racist
web
developer
patterns
and
practices
of
SharePoint
pyramid
patterns
and
practices.
If
you
go
a
kms
office
that
PNP
that's
one
location
for
all
of
these
resources,
but
we
do
have
channel
9
direct
links
as
well
or
MSDN
links
more
on
SharePoint
guidance
Yammer,
where
you
can
ask
questions
around.
A
For
example,
if
this
webcast
raised
the
questions
around
of
the
things
what
we
covered,
you
can
use
the
Gemma
group
at
the
PMB
Amacker
for
those
questions
as
well.
Monthly
community
calls
a
lot
of
stuffing
in
the
github.com
for
presentations
like
the
webcast
presentation.
What
we
just
went
through
is
available
within
the
Docs
that
comes
last
office,
dev
B&B,
but
I
think
that's
it
for
this
one
I
know:
bursa
PMP
parking
back
really
important
and
a
nice
demo
around
things,
but
I
think
that's
it
for
this
webcast
and
around
the
topics
of
dotnet
STK.
B
A
Absolutely
Thank
You
Paula
for
your
great
presentation
and
walkthrough
on
the
things
we'll
add
the
resources
links
to
those
individual
samples
and
and
all
of
the
other
resources
within
the
video
notes
as
well.
So
you
can
scroll
down
on
the
screen
if
you
are
using
a
browser
or
or
go
to
the
pages
where
we
release
the
webcast
for
additional
links
and
resources
around
to
cover
topics
but
I
think
that's
it.
So.
Thank
you,
everybody
for
watching
and
we'll
come
up
with
a
new
webcast
sooner
or
later.
Thank
you.