Récupérer contact exchange

Version imprimable

25/09/2013, 13h14
blackhox

Récupérer contact exchange

Bonjour à tous,

J'aurais voulu savoir si quelqu'un avait un bon tutoriel concernant la récupération des contacts stockés dans un exchange 2010?

Par exemple je voudrais faire un combobox avec les contacts exchange à disposition.

J'ai pu comprendre que pour faire ça, je pouvais utiliser EWS?

Est-ce une bonne solution?

Merci d'avance pour votre réponse.;)
25/09/2013, 14h01
DotNetMatt

Oui EWS est fait pour permettre à une application X de communiquer avec Exchange ;)

Voici un tuto : Querying the Global Address List (GAL) via Exchange Web Services (EWS). Si tu en veux d'autres, cherches sur Google avec l'expression "C# how to get exchange contacts" par exemple...

Citation:

Envoyé par DotNetMatt

Oui EWS est fait pour permettre à une application X de communiquer avec Exchange ;)

Voici un tuto : Querying the Global Address List (GAL) via Exchange Web Services (EWS). Si tu en veux d'autres, cherches sur Google avec l'expression "C# how to get exchange contacts" par exemple...

J'essaye de testé avec EWS

J'ai donc ajouté une référence de service :
https://myserver/EWS/Exchange.asmx (la connection s'est bien déroulée)

Lorsque je lance l'application, l'erreur suivant s'affiche :

La connexion sous-jacente a été fermée : Impossible d'établir une relation de confiance pour le canal sécurisé SSL/TLS.

Voici mon code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ConsoleApplication1.ServiceReference1;
using System.Net;
using System.Web;
 
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            ExchangeServiceBinding esb = new ExchangeServiceBinding();
            esb.Url = @"https://myserver/EWS/Exchange.asmx";
            esb.Credentials = new NetworkCredential(
                "user",
                @"password",
                @"domain");
 
            // Create the ResolveNamesType and set
            // the unresolved entry.
            ResolveNamesType rnType = new ResolveNamesType();
            rnType.ReturnFullContactData = true;
            rnType.UnresolvedEntry = "test";
 
            // Resolve names.
            ResolveNamesResponseType resolveNamesResponse
            = esb.ResolveNames(rnType);
            ArrayOfResponseMessagesType responses
            = resolveNamesResponse.ResponseMessages;
 
            // Check the result.
            if (responses.Items.Length > 0 &&
            responses.Items[0].ResponseClass
              != ResponseClassType.Error)
            {
                ResolveNamesResponseMessageType responseMessage =
              responses.Items[0] as
              ResolveNamesResponseMessageType;
 
                // Display the resolution information.
                ResolutionType[] resolutions =
              responseMessage.ResolutionSet.Resolution;
                foreach (ResolutionType resolution
              in resolutions)
                {
                    Console.WriteLine(
                "Name: " +
                resolution.Contact.DisplayName
                );
                    Console.WriteLine(
                "EmailAddress: " +
                resolution.Mailbox.EmailAddress
                );
 
                    if (resolution.Contact.PhoneNumbers != null)
                    {
                        foreach (
                  PhoneNumberDictionaryEntryType phone
                  in resolution.Contact.PhoneNumbers)
                        {
                            Console.WriteLine(
                    phone.Key.ToString() +
                    " : " +
                    phone.Value
                    );
                        }
                    }
                    Console.WriteLine(
                "Office location:" +
                resolution.Contact.OfficeLocation
                );
                    Console.WriteLine("\n");
                }
            }
        }
    }
}

Merci d'avance pour votre réponse;)

Voici mon nouveau code mais il affiche toujours l'erreur :

The request failed. La connexion sous-jacente a été fermée : Impossible d'établir une relation de confiance pour le canal sécurisé SSL/TLS.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static void Main(string[] args)
        {
            ExchangeService service = new ExchangeService();
            service.UseDefaultCredentials = true;
            service.Credentials = new WebCredentials("user", "password", "domain");
 
            service.Url = new Uri("https://mail.domain.com/EWS/Services.asmx");
 
 
            foreach (Contact contact in service.FindItems(WellKnownFolderName.Contacts, new ItemView(int.MaxValue)))
            {
                Console.WriteLine(contact);
            }
 
      }

J'ai réussi à supprimer l'erreur SSL/TLS via un code présent sur le MSDN...

Ce que je voudrais c'est obtenir la liste des contacts qui sont dans cette mailbox. Une idée SVP?

Merci d'avance pour votre réponse.;)

J'ai réussi à lire les mails présent dans la boite de réception grâce à ce code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
static void Main(string[] args)
        {
            ServicePointManager.ServerCertificateValidationCallback = delegate(Object obj, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
            {
                // If the certificate is a valid, signed certificate, return true.
                if (errors == System.Net.Security.SslPolicyErrors.None)
                {
                    return true;
                }
                // If there are errors in the certificate chain, look at each error to determine the cause.
                if ((errors & System.Net.Security.SslPolicyErrors.RemoteCertificateChainErrors) != 0)
                {
                    if (chain != null && chain.ChainStatus != null)
                    {
                        foreach (System.Security.Cryptography.X509Certificates.X509ChainStatus status in chain.ChainStatus)
                        {
                            if ((certificate.Subject == certificate.Issuer) &&
                               (status.Status == System.Security.Cryptography.X509Certificates.X509ChainStatusFlags.UntrustedRoot))
                            {
                                // Self-signed certificates with an untrusted root are valid.
                                continue;
                            }
                            else
                            {
                                if (status.Status != System.Security.Cryptography.X509Certificates.X509ChainStatusFlags.NoError)
                                {
                                    // If there are any other errors in the certificate chain, the certificate is invalid,
                                    // so the method returns false.
                                    return false;
                                }
                            }
                        }
                    }
                    // When processing reaches this line, the only errors in the certificate chain are
                    // untrusted root errors for self-signed certificates. These certificates are valid
                    // for default Exchange Server installations, so return true.
                    return true;
                }
                else
                {
                    // In all other cases, return false.
                    return false;
                }
            };
 
            ExchangeService _service = new ExchangeService(ExchangeVersion.Exchange2010);
            _service.Credentials = new WebCredentials("user", "password");
            _service.Url = new Uri("https://mail.domain.be/ews/exchange.asmx");
 
            //Mail dans mailbox
            FindItemsResults<Item> findResults =  _service.FindItems(
            WellKnownFolderName.Inbox, new ItemView(10));
 
            foreach (Item item in findResults.Items)
                Console.WriteLine(item.Subject);
            Console.ReadLine();

Voila! J'ai enfin réussi à récupérer les contacts via EWS

Voici le code pour ceux que ça interesse :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 static void Main(string[] args)
        {
 
 
            ServicePointManager.ServerCertificateValidationCallback = delegate(Object obj, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
            {
 
                if (errors == System.Net.Security.SslPolicyErrors.None)
                {
                    return true;
                }
 
                if ((errors & System.Net.Security.SslPolicyErrors.RemoteCertificateChainErrors) != 0)
                {
                    if (chain != null && chain.ChainStatus != null)
                    {
                        foreach (System.Security.Cryptography.X509Certificates.X509ChainStatus status in chain.ChainStatus)
                        {
                            if ((certificate.Subject == certificate.Issuer) &&
                               (status.Status == System.Security.Cryptography.X509Certificates.X509ChainStatusFlags.UntrustedRoot))
                            {
 
                                continue;
                            }
                            else
                            {
                                if (status.Status != System.Security.Cryptography.X509Certificates.X509ChainStatusFlags.NoError)
                                {
 
                                    return false;
                                }
                            }
                        }
                    }
 
                    return true;
                }
                else
                {
 
                    return false;
                }
            };
 
 
 
            ExchangeService _service = new ExchangeService(ExchangeVersion.Exchange2010);
            _service.Credentials = new WebCredentials("user", "password");
            _service.Url = new Uri("https://mail.domain.com/ews/exchange.asmx");
 
            //Contact mailbox
            ContactsFolder contactsfolder = ContactsFolder.Bind(_service, WellKnownFolderName.Contacts);
 
 
            int numItems = contactsfolder.TotalCount < int.MaxValue ? contactsfolder.TotalCount : int.MaxValue;
 
 
            ItemView view = new ItemView(numItems);
 
 
            view.PropertySet = new PropertySet(BasePropertySet.IdOnly, ContactSchema.DisplayName);
 
 
            FindItemsResults<Item> contactItems = _service.FindItems(WellKnownFolderName.Contacts, view);
 
 
            foreach (Item item in contactItems)
            {
 
                if (item is Contact)
                {
                    Contact contact = item as Contact;
                    Console.WriteLine(contact.DisplayName);
 
                }
 
            }
 
            Console.ReadLine();
 
        }