ContactManager Classe

Definição

Namespace:

System.Net.PeerToPeer.Collaboration

Assembly:

System.Net.dll

Representa uma coleção de objetos PeerContact que persistem em um Catálogo de Endereços do Windows.

public ref class ContactManager sealed : IDisposable

public sealed class ContactManager : IDisposable

type ContactManager = class
    interface IDisposable

Public NotInheritable Class ContactManager
Implements IDisposable

Herança

Object

ContactManager

Implementações

IDisposable

Exemplos

O código de exemplo a seguir ilustra como enumerar um PeerNearMe e adicioná-lo como um PeerContact ao 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;
}

Comentários

Essa classe não tem construtores públicos, pois uma referência a ela é retornada pela PeerCollaboration classe .

Os catálogos de endereços associados PeerContact ao gerenciamento incluem aqueles associados ao par de host e a um par remoto. Qualquer computador pode colaborar com outros pares; quando um par é local para o par remoto, mas não para o par de host, ele pode ser adicionado ao ContactManager do par de host. Determinadas operações na ContactManager classe, como AddContact e DeleteContact, correlacionam-se às operações associadas que estão sendo executadas no catálogo de endereços do Windows do par remoto.

O par de host tem acesso a esse armazenamento persistente para PeerContact obter informações, que podem ser associadas aos aplicativos nos quais um par pretende participar. Um PeerApplication pode se identificar como um usuário de um ContactManager repositório persistente em um computador.

Propriedades

LocalContact	Obtém o PeerContact que representa o par local.
SynchronizingObject	Quando este valor da propriedade é definido, todos os eventos não acionados como o resultado de uma operação assíncrona terão os manipuladores de evento associados chamados de volta no thread que criou o SynchronizingObject específico.

Métodos

AddContact(PeerContact)	Adiciona o PeerContact especificado ao ContactManager do par local.
CreateContact(PeerNearMe)	Cria uma instância PeerContact para o objeto PeerNearMe especificado.
CreateContactAsync(PeerNearMe, Object)	Cria uma instância de contato para o objeto PeerNearMe especificado.
DeleteContact(PeerContact)	Remove o PeerContact especificado do ContactManager do par local.
DeleteContact(PeerName)	Remove o PeerContact associado ao PeerName especificado do ContactManager do par local.
Dispose()	Libera todos os recursos usados pelo objeto ContactManager.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetContact(PeerName)	Retorna o objeto PeerContact para o objeto PeerName especificado.
GetContacts()	Retorna um PeerContactCollection que contém todos os contatos dentro do ContactManager do par remoto.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
UpdateContact(PeerContact)	Atualiza os dados associados ao PeerContact.

Eventos

ApplicationChanged	Gerado sempre que um PeerApplication associado a um PeerContact no ContactManager foi alterado.
CreateContactCompleted	Gerado sempre que um método CreateContact(PeerNearMe) tiver sido concluído.
NameChanged	Gerado sempre que o PeerName associado a um PeerContact no ContactManager tiver sido alterado.
ObjectChanged	Gerado sempre que um objeto dentro dos objetos PeerObject registrados de um contato é alterado.
PresenceChanged	Gerado sempre que o status de presença de um PeerContact no ContactManager tiver sido alterado.
SubscriptionListChanged	Gerando quando a lista de contatos assinados é alterada.

Confira também

• GetContact(PeerName)
• CreateContact(PeerNearMe)
• UpdateContact(PeerContact)