ContactManager Classe

Definizione

Rappresenta un insieme di oggetti PeerContact salvati in modo permanente in una Rubrica di Windows.Represents a collection of PeerContact objects which persist in a Windows Address Book.

public ref class ContactManager sealed : IDisposable
public sealed class ContactManager : IDisposable
type ContactManager = class
    interface IDisposable
Public NotInheritable Class ContactManager
Implements IDisposable
Ereditarietà
ContactManager
Implementazioni

Esempio

Nell'esempio di codice riportato di seguito viene illustrato come PeerNearMe enumerare un oggetto e PeerContact aggiungerlo come ContactManagerall'oggetto locale:The following example code illustrates how to enumerate a PeerNearMe and add it as a PeerContact to the local ContactManager:

   // Displays all contacts and asssociated peer endpoints (PeerEndPoint) in the PeerContactCollection.
   private static void DisplayContacts(PeerContactCollection peerContactsCollection)
   {
       if (peerContactsCollection == null ||
           peerContactsCollection.Count == 0)
       {
           Console.WriteLine("No contacts to display. To add a contact select option 0 from the menu.");
       }
       else
       {
           foreach (PeerContact pc in peerContactsCollection)
           {
               Console.WriteLine("The contact is: {0}", pc.DisplayName);
               DisplayEndpoints(pc.PeerEndPoints);
           }
       }
       return;
   }
   
   //------------------------------------------------------------------------------------------------------
   //------------------------------------------------------------------------------------------------------
   // Displays all peer end points (PeerEndPoint) in the PeerEndPointCollection.

   private static void DisplayEndpoints(PeerEndPointCollection endpointCollection)
   {
       if (endpointCollection == null ||  endpointCollection.Count == 0)
       {
           Console.WriteLine("No peer endpoints in the collection to display.");
       }
       else
       {
           foreach (PeerEndPoint pep in endpointCollection)
           {
               Console.WriteLine("PeerEndPoint is: {0}", pep);
               Console.WriteLine("PeerEndPoint data is:\n  Name: {0}\n EndPoint IP address: {1}\n . Port: {2}\n",
                   pep.Name,
                   pep.EndPoint.Address,
                   pep.EndPoint.Port);
           }
       }
       return;
   }
   
   //------------------------------------------------------------------------------------------------------
   //------------------------------------------------------------------------------------------------------
   //List PeerNearMe objects that may be added as contacts.
   
   private static void AddContact()
   {
       PeerNearMeCollection pnmc = null;
       PeerContactCollection peerContacts = null;            
       bool peerNameFound = false;

       PeerApplication application = null;

       try
       {
           Console.WriteLine("Listing the existing contacts...");
           peerContacts = PeerCollaboration.ContactManager.GetContacts();
       }
       catch (PeerToPeerException p2pEx)
       {
           Console.WriteLine("The Peer Collaboration Infrastructure is not responding to the contact enumeration request: {0}", p2pEx.Message);
       }
       catch (Exception ex)
       {
           Console.WriteLine("An unexpected error occurred while attempting to obtain the contact list: {0}", ex.Message);
       }

       DisplayContacts(peerContacts);

       try
       {
           //Adds one of the PeerNearMe objects as a contact.                               
           pnmc = GetPeersNearMe();
           Console.WriteLine("Please enter the nickname of the peer you wish to add as a contact:");
           string peerNameToAdd = Console.ReadLine();

           application = RegisterCollabApp();

           foreach (PeerNearMe pnm in pnmc)
           {
               PeerInvitationResponse res = null;
               if (pnm.Nickname.Contains(peerNameToAdd))
               {
                   peerNameFound = true;
                   if (!peerContacts.ToString().Contains(pnm.Nickname))
                   {
                       Console.WriteLine("Adding peer {0} to the contact list.", pnm.Nickname);
                       pnm.AddToContactManager();
                   }
                   else
                   {
                       Console.WriteLine("This peer already exists in your contact list.");
                       Console.WriteLine("Sending invitation using the Contact structure instead of the PeerNearMe.");
                       foreach (PeerContact pc in peerContacts)
                       {
                           if (pc.Nickname.Equals(pnm.Nickname))
                           {
                               res = pnm.Invite(application, "Peer Collaboration Sample", application.Data);
                               if (res.PeerInvitationResponseType == PeerInvitationResponseType.Accepted)
                               {
                                   Console.WriteLine("Invitation to contact succeeded.");
                               }
                               else
                               {
                                   Console.WriteLine("Invitation to contact {0}.", res.PeerInvitationResponseType);
                               }
                           }
                       }
                   }
               }
           }

           if (!peerNameFound)
           {
               Console.WriteLine("No such peer exists near you. Cannot add to contacts.");
               return;
           }

           peerContacts = PeerCollaboration.ContactManager.GetContacts();

           Console.WriteLine("Listing the contacts again...");
           DisplayContacts(peerContacts);
       }
       catch (Exception ex)
       {
           Console.WriteLine("Error adding a contact: {0}", ex.Message);
       }
       finally
       {
           application.Dispose();
       }
       return;
   }

Commenti

Questa classe non ha costruttori pubblici, perché un riferimento a esso viene restituito dalla PeerCollaboration classe.This class has no public constructors, since a reference to it is returned by the PeerCollaboration class.

Le rubriche PeerContact associate alla gestione includono quelle associate al peer host e a un peer remoto.Address books that are associated with PeerContact management include those associated with the host peer and a remote peer. È possibile che entrambi i computer collaborino con altri peer. Quando un peer è locale al peer remoto ma non al peer host, può essere aggiunto a ContactManager del peer host.Either computer may collaborate with other peers; when a peer is local to the remote peer but not the host peer, it can be added to the ContactManager of the host peer. Alcune operazioni sulla ContactManager classe, AddContact ad esempio e DeleteContact, sono correlate alle operazioni associate eseguite nella Rubrica di Windows del peer remoto.Certain operations on the ContactManager class, such as AddContact and DeleteContact, correlate to the associated operations being performed on the Windows Address book of the remote peer.

Il peer host ha accesso a questa risorsa di archiviazione PeerContact permanente per informazioni che possono essere associate alle applicazioni in cui un peer intende partecipare.The host peer has access to this persistent storage for PeerContact information, which can be associated with the applications in which a peer intends to participate. Un PeerApplication oggetto può identificarsi come un utente di ContactManager un archivio permanente in un computer.A PeerApplication can identify itself as a user of a ContactManager persistent store on a computer.

Proprietà

LocalContact

Ottiene l'oggetto PeerContact che rappresenta il peer locale.Gets the PeerContact representing the local peer.

SynchronizingObject

Quando si imposta questo valore di proprietà, i gestori eventi di tutti gli eventi non generati a seguito di un'operazione asincrona verranno richiamati nel thread che ha creato l'oggetto SynchronizingObject specifico.When this property value is set, all events not fired as the result of an asynchronous operation will have the associated event handlers called back on the thread that created the specific SynchronizingObject.

Metodi

AddContact(PeerContact)

Aggiunge l'oggetto PeerContact specificato all'oggetto ContactManager del peer locale.Adds the specified PeerContact to the ContactManager of the local peer.

CreateContact(PeerNearMe)

Crea un'istanza di PeerContact per l'oggetto PeerNearMe specificato.Creates a PeerContact instance for the specified PeerNearMe object.

CreateContactAsync(PeerNearMe, Object)

Crea un'istanza di contatto per l'oggetto PeerNearMe specificato.Creates a contact instance for the specified PeerNearMe object.

DeleteContact(PeerContact)

Rimuove l'oggetto PeerContact specificato da ContactManager del peer locale.Removes the specified PeerContact from the ContactManager of the local peer.

DeleteContact(PeerName)

Rimuove l'oggetto PeerContact associato alla proprietà PeerName specificata da ContactManager del peer locale.Removes the PeerContact associated with the specified PeerName from the ContactManager of the local peer.

Dispose()

Rilascia tutte le risorse usate dall'oggetto ContactManager.Releases all resources used by the ContactManager object.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetContact(PeerName)

Restituisce l'oggetto PeerContact relativo all'oggetto PeerName specificato.Returns the PeerContact object for the specified PeerName.

GetContacts()

Restituisce un PeerContactCollection contenente tutti i contatti presenti all'interno dell'oggetto ContactManager del peer remoto.Returns a PeerContactCollection that contains all contacts within the ContactManager of the remote peer.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
UpdateContact(PeerContact)

Aggiorna i dati associati a PeerContact.Updates the data associated with the PeerContact.

Eventi

ApplicationChanged

Generato ogni volta che un PeerApplication associato a un PeerContact contenuto in ContactManager è stato modificato.Raised whenever a PeerApplication associated with a PeerContact in the ContactManager has changed.

CreateContactCompleted

Generato ogni volta che viene completata l'esecuzione di un metodo CreateContact(PeerNearMe).Raised whenever a CreateContact(PeerNearMe) method has completed.

NameChanged

Generato ogni volta che l'oggetto PeerName associato a un PeerContact contenuto in ContactManager è stato modificato.Raised whenever the PeerName associated with a PeerContact in the ContactManager has changed.

ObjectChanged

Generato ogni volta che viene modificato uno degli oggetti PeerObject registrati in un contatto.Raised whenever an object within a contact's registered PeerObject objects has changed.

PresenceChanged

Questo evento viene generato ogni volta che viene modificato lo stato di presenza di un PeerContact contenuto in ContactManager.Raised whenever the presence status of a PeerContact in the ContactManager has changed.

SubscriptionListChanged

Generato quando viene modificato l'elenco dei contatti sottoscritti.Raised when the list of subscribed contacts changes.

Si applica a

Vedi anche