// First, set up the binding to Exchange Web Services.
ExchangeServiceBinding binding = new ExchangeServiceBinding();
binding.Credentials = new NetworkCredential("fred", "Pa$$word", "contoso");
binding.Url = @"https://exchange.contoso.com/EWS/Exchange.asmx";
//
// Next, call FindItem for the Inbox folder.
// Form the FindItem request.
FindItemType findItemRequest = new FindItemType();
findItemRequest.Traversal = ItemQueryTraversalType.Shallow;
//
// Define which item properties are returned in the response.
// We only need the ItemIds.
ItemResponseShapeType itemProperties = new ItemResponseShapeType();
itemProperties.BaseShape = DefaultShapeNamesType.IdOnly;
//
// Add the properties shape to request.
findItemRequest.ItemShape = itemProperties;
//
// Identify which folders to search to find items.
DistinguishedFolderIdType[] folderIDArray = new DistinguishedFolderIdType[2];
folderIDArray[0] = new DistinguishedFolderIdType();
folderIDArray[0].Id = DistinguishedFolderIdNameType.inbox;
//
// Add folders to the request.
findItemRequest.ParentFolderIds = folderIDArray;
//
// Send the request and get the response.
FindItemResponseType findItemResponse = binding.FindItem(findItemRequest);
//
// Next, enumerate through the Items returned by FindItem.
foreach (FindItemResponseMessageType responseMessage in findItemResponse.ResponseMessages.Items)
{
if (responseMessage.ResponseClass == ResponseClassType.Success)
{
ArrayOfRealItemsType mailboxItems =
                (ArrayOfRealItemsType)responseMessage.RootFolder.Item;

for (int itemCount = 0; itemCount <
                mailboxItems.Items.Length; itemCount++)
{
ItemType inboxItem = mailboxItems.Items[itemCount];
                  // Call GetItem on each ItemId to retrieve the 
                  // item's Body property and any AttachmentIds.
                  //
 // Form the GetItem request.
GetItemType getItemRequest = new GetItemType();

getItemRequest.ItemShape = 
                      new ItemResponseShapeType();
// AllProperties on a GetItem request WILL return 
                  // the message body.
getItemRequest.ItemShape.BaseShape = 
                      DefaultShapeNamesType.AllProperties;

getItemRequest.ItemIds = new ItemIdType[1];
getItemRequest.ItemIds[0] = 
                      (BaseItemIdType)inboxItem.ItemId;

GetItemResponseType getItemResponse =
                      binding.GetItem(getItemRequest);

// We only passed in one ItemId to the GetItem
                  // request. Therefore, we can assume that
// we got at most one Item back.
ItemInfoResponseMessageType getItemResponseMessage = 
                      getItemResponse.ResponseMessages.Items[0] as
                      ItemInfoResponseMessageType;
if (getItemResponseMessage != null)
{
if (getItemResponseMessage.ResponseClass ==
                            ResponseClassType.Success &&
getItemResponseMessage.Items.Items !=
                              null &&
                              getItemResponseMessage.Items.Items.Length
                              > 0)
{
inboxItem =
                                 getItemResponseMessage.Items.Items[0];
}
else
{
return;
}
}
else
{
return;
}

// Now the message Body is there.
BodyType messageBody = inboxItem.Body;
                  //
                  // You now have the mailbox item's Body property
                  // and you can use it as needed.
                  //
// Check for attachments.
if (inboxItem.HasAttachments)
{
AttachmentType[] attachments =
                            inboxItem.Attachments;
                        //
// Enumerate through the attachments.
for (int attachmentCount = 0; 
                            attachmentCount < attachments.Length;
                            attachmentCount++)
{
// Form the GetAttachment request.
GetAttachmentType getAttachmentRequest =
                                  new GetAttachmentType();
                              //
// Add the attachment to retrieve.
RequestAttachmentIdType[]
                                  attachmentIDArray = 
                                  new RequestAttachmentIdType[1];
attachmentIDArray[0] = 
                                  new RequestAttachmentIdType();
attachmentIDArray[0].Id =
                         attachments[attachmentCount].AttachmentId.Id;
getAttachmentRequest.AttachmentIds =
                                  attachmentIDArray;
                              //
// Make the GetAttachment request.
GetAttachmentResponseType
                                  getAttachmentResponse =
                           binding.GetAttachment(getAttachmentRequest);
                              //
                              // We then parse through the 
                              // GetAttachment response to get the 
                              //attachment object itself
                              //
// We only passed in one AttachmentId.
                              // Therefore, we can assume that we
// got at most one attachment back.
AttachmentInfoResponseMessageType 
                                  attachmentResponseMessage = 
                       getAttachmentResponse.ResponseMessages.Items[0]
                                 as AttachmentInfoResponseMessageType;
if (attachmentResponseMessage != null)
{
if 
                           (attachmentResponseMessage.ResponseClass 
                           == ResponseClassType.Success &&
                           attachmentResponseMessage.Attachments !=
                           null &&
                           attachmentResponseMessage.Attachments.Length
                           > 0)
{
AttachmentType attachment = 
                              attachmentResponseMessage.Attachments[0];
}
else
{
return;
}
}
else
{
return;
}

}
} 
}
      }
}