ContactManager Classe

  • Referência

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 par de host. Determinadas operações na ContactManager classe, como AddContact eDeleteContact, correlacionam-se com as operações associadas que estão sendo executadas no Windows catálogo de endereços 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. A PeerApplication pode identificar-se 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.

Aplica-se a

Confira também