ContactManager Classe

  • Riferimento

Definizione

Spazio dei nomi:
System.Net.PeerToPeer.Collaboration
Assembly:
System.Net.dll

Rappresenta un insieme di oggetti PeerContact salvati in modo permanente in una Rubrica di Windows.

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

Esempio

Il codice di esempio seguente illustra come enumerare un PeerNearMe oggetto e aggiungerlo come oggetto PeerContact all'oggetto locale 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, poiché viene restituito un riferimento alla PeerCollaboration classe.

Le rubriche associate alla PeerContact gestione includono quelle associate al peer host e a un peer remoto. Entrambi i computer possono collaborare con altri peer; quando un peer è locale al peer remoto, ma non al peer host, può essere aggiunto al ContactManager peer host. Alcune operazioni sulla ContactManager classe, ad esempio AddContact e DeleteContact, correlano alle operazioni associate eseguite sulla Windows Rubrica del peer remoto.

Il peer host ha accesso a questa risorsa di archiviazione persistente per PeerContact informazioni, che possono essere associate alle applicazioni in cui un peer intende partecipare. Un PeerApplication oggetto può identificarsi come utente di un ContactManager archivio permanente in un computer.

Proprietà

LocalContact

Ottiene l'oggetto PeerContact che rappresenta il peer locale.
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.

Metodi

AddContact(PeerContact)

Aggiunge l'oggetto PeerContact specificato all'oggetto ContactManager del peer locale.
CreateContact(PeerNearMe)

Crea un'istanza di PeerContact per l'oggetto PeerNearMe specificato.
CreateContactAsync(PeerNearMe, Object)

Crea un'istanza di contatto per l'oggetto PeerNearMe specificato.
DeleteContact(PeerContact)

Rimuove l'oggetto PeerContact specificato da ContactManager del peer locale.
DeleteContact(PeerName)

Rimuove l'oggetto PeerContact associato alla proprietà PeerName specificata da ContactManager del peer locale.
Dispose()

Rilascia tutte le risorse usate dall'oggetto ContactManager.
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetContact(PeerName)

Restituisce l'oggetto PeerContact relativo all'oggetto PeerName specificato.
GetContacts()

Restituisce un PeerContactCollection contenente tutti i contatti presenti all'interno dell'oggetto ContactManager del peer remoto.
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)
UpdateContact(PeerContact)

Aggiorna i dati associati a PeerContact.

Eventi

ApplicationChanged

Generato ogni volta che un PeerApplication associato a un PeerContact contenuto in ContactManager è stato modificato.
CreateContactCompleted

Generato ogni volta che viene completata l'esecuzione di un metodo CreateContact(PeerNearMe).
NameChanged

Generato ogni volta che l'oggetto PeerName associato a un PeerContact contenuto in ContactManager è stato modificato.
ObjectChanged

Generato ogni volta che viene modificato uno degli oggetti PeerObject registrati in un contatto.
PresenceChanged

Questo evento viene generato ogni volta che viene modificato lo stato di presenza di un PeerContact contenuto in ContactManager.
SubscriptionListChanged

Generato quando viene modificato l'elenco dei contatti sottoscritti.

Si applica a

Vedi anche