Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / SystemNet / Net / PeerToPeer / Collaboration / PeerEndPoint.cs / 1305376 / PeerEndPoint.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Net.PeerToPeer.Collaboration
{
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.Runtime.InteropServices;
using System.Net.Sockets;
using System.ComponentModel;
using System.Threading;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.Serialization;
using System.Security.Permissions;
///
/// This is the event args class we give back when
/// we have have a name changed event fired by native
///
public class NameChangedEventArgs : EventArgs
{
private PeerEndPoint m_peerEndPoint;
private PeerContact m_peerContact;
private string m_name;
internal NameChangedEventArgs(PeerEndPoint peerEndPoint, PeerContact peerContact,
string name)
{
m_peerEndPoint = peerEndPoint;
m_peerContact = peerContact;
m_name = name;
}
public PeerEndPoint PeerEndPoint
{
get{
return m_peerEndPoint;
}
}
public PeerContact PeerContact
{
get{
return m_peerContact;
}
}
public string Name
{
get{
return m_name;
}
}
}
///
/// PeerEndpoint class encapsulates the functionality of an
/// endpoint in the peer collaboration scope.
///
[Serializable]
public class PeerEndPoint : IDisposable, IEquatable, ISerializable
{
private string m_endPointName;
private IPEndPoint m_endPoint;
private ISynchronizeInvoke m_synchronizingObject;
public PeerEndPoint() { }
public PeerEndPoint(IPEndPoint endPoint):this(endPoint, null)
{ }
public PeerEndPoint(IPEndPoint endPoint, string endPointName)
{
if (endPoint == null){
throw new ArgumentNullException("endPoint");
}
//
// Validate that this is an IPv6 address
//
if ((m_endPoint != null) && (m_endPoint.AddressFamily != AddressFamily.InterNetworkV6)){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerEndPoint Endpoint set parameter is not IPv6.");
throw new ArgumentException("endPoint", SR.GetString(SR.Collab_EndPointNotIPv6Error));
}
m_endPoint = endPoint;
m_endPointName = endPointName;
}
///
/// Constructor to enable serialization
///
protected PeerEndPoint(SerializationInfo serializationInfo, StreamingContext streamingContext)
{
m_endPointName = serializationInfo.GetString("_EndPointName");
m_endPoint = (IPEndPoint)serializationInfo.GetValue("_EndPoint", typeof(IPEndPoint));
}
public string Name
{
get { return m_endPointName; }
set { m_endPointName = value; }
}
public IPEndPoint EndPoint
{
get { return m_endPoint; }
set {
//
// Validate that this is an IPv6 address
//
if ((m_endPoint != null) && (m_endPoint.AddressFamily != AddressFamily.InterNetworkV6)){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerEndPoint Endpoint set parameter is not IPv6.");
throw new PeerToPeerException(SR.GetString(SR.Collab_EndPointNotIPv6Error));
}
m_endPoint = value;
}
}
///
/// Gets and set the object used to marshall event handlers calls for stand alone
/// events
///
[Browsable(false), DefaultValue(null), Description(SR.SynchronizingObject)]
public ISynchronizeInvoke SynchronizingObject
{
get
{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
return m_synchronizingObject;
}
set
{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
m_synchronizingObject = value;
}
}
private event EventHandler m_nameChanged;
public event EventHandler NameChanged
{
//
//
[System.Security.SecurityCritical]
add{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
CollaborationHelperFunctions.Initialize();
PeerCollaborationPermission.UnrestrictedPeerCollaborationPermission.Demand();
AddNameChanged(value);
}
//
//
[System.Security.SecurityCritical]
remove{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
CollaborationHelperFunctions.Initialize();
PeerCollaborationPermission.UnrestrictedPeerCollaborationPermission.Demand();
RemoveNameChanged(value);
}
}
#region Name changed event variables
private object m_lockNameChangedEvent;
private object LockNameChangedEvent
{
get{
if (m_lockNameChangedEvent == null){
object o = new object();
Interlocked.CompareExchange(ref m_lockNameChangedEvent, o, null);
}
return m_lockNameChangedEvent;
}
}
private RegisteredWaitHandle m_regNameChangedWaitHandle;
private AutoResetEvent m_nameChangedEvent;
private SafeCollabEvent m_safeNameChangedEvent;
#endregion
//
//
[System.Security.SecurityCritical]
private void AddNameChanged(EventHandler callback)
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Entering AddNameChanged().");
//
// Register a wait handle if one has not been registered already
//
lock (LockNameChangedEvent){
if (m_nameChanged == null){
m_nameChangedEvent = new AutoResetEvent(false);
//
// Register callback with a wait handle
//
m_regNameChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_nameChangedEvent, //Event that triggers the callback
new WaitOrTimerCallback(NameChangedCallback), //callback to be called
null, //state to be passed
-1, //Timeout - aplicable only for timers
false //call us everytime the event is set
);
PEER_COLLAB_EVENT_REGISTRATION pcer = new PEER_COLLAB_EVENT_REGISTRATION();
pcer.eventType = PeerCollabEventType.EndPointChanged;
pcer.pInstance = IntPtr.Zero;
//
// Register event with collab
//
int errorCode = UnsafeCollabNativeMethods.PeerCollabRegisterEvent(
m_nameChangedEvent.SafeWaitHandle,
1,
ref pcer,
out m_safeNameChangedEvent);
if (errorCode != 0){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerCollabRegisterEvent returned with errorcode {0}", errorCode);
throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Collab_NameChangedRegFailed), errorCode);
}
}
m_nameChanged += callback;
}
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "AddNameChanged() successful.");
}
//
//
[System.Security.SecurityCritical]
private void RemoveNameChanged(EventHandler callback)
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "RemoveNameChanged() called.");
lock (LockNameChangedEvent){
m_nameChanged -= callback;
if (m_nameChanged == null){
CollaborationHelperFunctions.CleanEventVars(ref m_regNameChangedWaitHandle,
ref m_safeNameChangedEvent,
ref m_nameChangedEvent);
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Clean NameChanged variables successful.");
}
}
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "RemoveNameChanged() successful.");
}
//
//
[System.Security.SecurityCritical]
private void NameChangedCallback(object state, bool timedOut)
{
SafeCollabData eventData = null;
int errorCode = 0;
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "NameChangedCallback() called.");
if (m_Disposed) return;
while (true){
NameChangedEventArgs nameChangedArgs = null;
//
// Get the event data for the fired event
//
try{
lock (LockNameChangedEvent)
{
if (m_safeNameChangedEvent.IsInvalid) return;
errorCode = UnsafeCollabNativeMethods.PeerCollabGetEventData(m_safeNameChangedEvent,
out eventData);
}
if (errorCode == UnsafeCollabReturnCodes.PEER_S_NO_EVENT_DATA)
break;
else if (errorCode != 0){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerCollabGetEventData returned with errorcode {0}", errorCode);
throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Collab_GetNameChangedDataFailed), errorCode);
}
PEER_COLLAB_EVENT_DATA ped = (PEER_COLLAB_EVENT_DATA)Marshal.PtrToStructure(eventData.DangerousGetHandle(),
typeof(PEER_COLLAB_EVENT_DATA));
if (ped.eventType == PeerCollabEventType.EndPointChanged){
PEER_EVENT_ENDPOINT_CHANGED_DATA epData = ped.endpointChangedData;
PeerEndPoint peerEndPoint = null;
if (epData.pEndPoint != IntPtr.Zero){
PEER_ENDPOINT pe = (PEER_ENDPOINT)Marshal.PtrToStructure(epData.pEndPoint, typeof(PEER_ENDPOINT));
peerEndPoint = CollaborationHelperFunctions.ConvertPEER_ENDPOINTToPeerEndPoint(pe);
}
if ((peerEndPoint != null) && Equals(peerEndPoint)){
PeerContact peerContact = null;
if (epData.pContact != IntPtr.Zero){
PEER_CONTACT pc = (PEER_CONTACT)Marshal.PtrToStructure(epData.pContact, typeof(PEER_CONTACT));
peerContact = CollaborationHelperFunctions.ConvertPEER_CONTACTToPeerContact(pc);
}
nameChangedArgs = new NameChangedEventArgs(peerEndPoint,
peerContact,
peerEndPoint.Name);
}
}
}
finally{
if (eventData != null) eventData.Dispose();
}
//
// Fire the callback with the marshalled event args data
//
if (nameChangedArgs != null){
OnNameChanged(nameChangedArgs);
//
// Change the name with the new name
//
Name = nameChangedArgs.PeerEndPoint.Name;
}
}
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Leaving NameChangedCallback().");
}
protected void OnNameChanged(NameChangedEventArgs nameChangedArgs)
{
EventHandler handlerCopy = m_nameChanged;
if (handlerCopy != null){
if (SynchronizingObject != null && SynchronizingObject.InvokeRequired)
SynchronizingObject.BeginInvoke(handlerCopy, new object[] { this, nameChangedArgs });
else
handlerCopy(this, nameChangedArgs);
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Fired the name changed event callback.");
}
}
public bool Equals(PeerEndPoint other)
{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
//
// Equality means same ipendpoints
//
if (other != null){
return other.EndPoint.Equals(EndPoint);
}
return false;
}
public override bool Equals(object obj)
{
PeerEndPoint comparandPeerEndPoint = obj as PeerEndPoint;
if (comparandPeerEndPoint != null){
return comparandPeerEndPoint.EndPoint.Equals(EndPoint);
}
return false;
}
public new static bool Equals(object objA, object objB)
{
PeerEndPoint comparandPeerEndPoint1 = objA as PeerEndPoint;
PeerEndPoint comparandPeerEndPoint2 = objB as PeerEndPoint;
if ((comparandPeerEndPoint1 != null) && (comparandPeerEndPoint2 != null)){
return comparandPeerEndPoint1.EndPoint.Equals(comparandPeerEndPoint2.EndPoint);
}
return false;
}
public override int GetHashCode()
{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
return EndPoint.GetHashCode();
}
public override string ToString()
{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
return m_endPointName;
}
private bool m_Disposed;
//
//
[System.Security.SecurityCritical]
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
//
//
[System.Security.SecurityCritical]
protected virtual void Dispose(bool disposing)
{
if (!m_Disposed){
CollaborationHelperFunctions.CleanEventVars(ref m_regNameChangedWaitHandle,
ref m_safeNameChangedEvent,
ref m_nameChangedEvent);
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Clean NameChanged variables successful.");
}
m_Disposed = true;
}
//
//
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase", Justification = "System.Net.dll is still using pre-v4 security model and needs this demand")]
[System.Security.SecurityCritical]
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter, SerializationFormatter = true)]
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
{
GetObjectData(info, context);
}
///
/// This is made virtual so that derived types can be implemented correctly
///
[SecurityPermission(SecurityAction.LinkDemand, SerializationFormatter = true)]
protected virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("_EndPointName", m_endPointName);
info.AddValue("_EndPoint", m_endPoint);
}
internal void TracePeerEndPoint()
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Contents of the PeerEndPoint");
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "\tEndPoint: {0}", (EndPoint != null? EndPoint.ToString(): null));
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "\tDescription: {0}", Name);
}
}
///
/// Represents a collection of PeerEndPoints
///
[Serializable]
public class PeerEndPointCollection : Collection, IEquatable
{
internal PeerEndPointCollection() { }
protected override void SetItem(int index, PeerEndPoint item)
{
//
// Null peerendpoints not allowed
//
if (item == null){
throw new ArgumentNullException("item");
}
base.SetItem(index, item);
}
protected override void InsertItem(int index, PeerEndPoint item)
{
//
// Null peerendpoints not allowed
//
if (item == null){
throw new ArgumentNullException("item");
}
base.InsertItem(index, item);
}
public override string ToString()
{
bool first = true;
StringBuilder builder = new StringBuilder();
foreach (PeerEndPoint peerEndPoint in this){
if (!first){
builder.Append(", ");
}
else{
first = false;
}
builder.Append(peerEndPoint.ToString());
}
return builder.ToString();
}
public bool Equals(PeerEndPointCollection other)
{
bool equal = false;
if (other != null){
foreach (PeerEndPoint peerEndPoint1 in other)
foreach (PeerEndPoint peerEndPoint2 in this)
if (!peerEndPoint1.Equals(peerEndPoint2)){
return equal;
}
equal = true;
}
return equal;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Net.PeerToPeer.Collaboration
{
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text;
using System.Runtime.InteropServices;
using System.Net.Sockets;
using System.ComponentModel;
using System.Threading;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.Serialization;
using System.Security.Permissions;
///
/// This is the event args class we give back when
/// we have have a name changed event fired by native
///
public class NameChangedEventArgs : EventArgs
{
private PeerEndPoint m_peerEndPoint;
private PeerContact m_peerContact;
private string m_name;
internal NameChangedEventArgs(PeerEndPoint peerEndPoint, PeerContact peerContact,
string name)
{
m_peerEndPoint = peerEndPoint;
m_peerContact = peerContact;
m_name = name;
}
public PeerEndPoint PeerEndPoint
{
get{
return m_peerEndPoint;
}
}
public PeerContact PeerContact
{
get{
return m_peerContact;
}
}
public string Name
{
get{
return m_name;
}
}
}
///
/// PeerEndpoint class encapsulates the functionality of an
/// endpoint in the peer collaboration scope.
///
[Serializable]
public class PeerEndPoint : IDisposable, IEquatable, ISerializable
{
private string m_endPointName;
private IPEndPoint m_endPoint;
private ISynchronizeInvoke m_synchronizingObject;
public PeerEndPoint() { }
public PeerEndPoint(IPEndPoint endPoint):this(endPoint, null)
{ }
public PeerEndPoint(IPEndPoint endPoint, string endPointName)
{
if (endPoint == null){
throw new ArgumentNullException("endPoint");
}
//
// Validate that this is an IPv6 address
//
if ((m_endPoint != null) && (m_endPoint.AddressFamily != AddressFamily.InterNetworkV6)){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerEndPoint Endpoint set parameter is not IPv6.");
throw new ArgumentException("endPoint", SR.GetString(SR.Collab_EndPointNotIPv6Error));
}
m_endPoint = endPoint;
m_endPointName = endPointName;
}
///
/// Constructor to enable serialization
///
protected PeerEndPoint(SerializationInfo serializationInfo, StreamingContext streamingContext)
{
m_endPointName = serializationInfo.GetString("_EndPointName");
m_endPoint = (IPEndPoint)serializationInfo.GetValue("_EndPoint", typeof(IPEndPoint));
}
public string Name
{
get { return m_endPointName; }
set { m_endPointName = value; }
}
public IPEndPoint EndPoint
{
get { return m_endPoint; }
set {
//
// Validate that this is an IPv6 address
//
if ((m_endPoint != null) && (m_endPoint.AddressFamily != AddressFamily.InterNetworkV6)){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerEndPoint Endpoint set parameter is not IPv6.");
throw new PeerToPeerException(SR.GetString(SR.Collab_EndPointNotIPv6Error));
}
m_endPoint = value;
}
}
///
/// Gets and set the object used to marshall event handlers calls for stand alone
/// events
///
[Browsable(false), DefaultValue(null), Description(SR.SynchronizingObject)]
public ISynchronizeInvoke SynchronizingObject
{
get
{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
return m_synchronizingObject;
}
set
{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
m_synchronizingObject = value;
}
}
private event EventHandler m_nameChanged;
public event EventHandler NameChanged
{
//
//
[System.Security.SecurityCritical]
add{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
CollaborationHelperFunctions.Initialize();
PeerCollaborationPermission.UnrestrictedPeerCollaborationPermission.Demand();
AddNameChanged(value);
}
//
//
[System.Security.SecurityCritical]
remove{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
CollaborationHelperFunctions.Initialize();
PeerCollaborationPermission.UnrestrictedPeerCollaborationPermission.Demand();
RemoveNameChanged(value);
}
}
#region Name changed event variables
private object m_lockNameChangedEvent;
private object LockNameChangedEvent
{
get{
if (m_lockNameChangedEvent == null){
object o = new object();
Interlocked.CompareExchange(ref m_lockNameChangedEvent, o, null);
}
return m_lockNameChangedEvent;
}
}
private RegisteredWaitHandle m_regNameChangedWaitHandle;
private AutoResetEvent m_nameChangedEvent;
private SafeCollabEvent m_safeNameChangedEvent;
#endregion
//
//
[System.Security.SecurityCritical]
private void AddNameChanged(EventHandler callback)
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Entering AddNameChanged().");
//
// Register a wait handle if one has not been registered already
//
lock (LockNameChangedEvent){
if (m_nameChanged == null){
m_nameChangedEvent = new AutoResetEvent(false);
//
// Register callback with a wait handle
//
m_regNameChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_nameChangedEvent, //Event that triggers the callback
new WaitOrTimerCallback(NameChangedCallback), //callback to be called
null, //state to be passed
-1, //Timeout - aplicable only for timers
false //call us everytime the event is set
);
PEER_COLLAB_EVENT_REGISTRATION pcer = new PEER_COLLAB_EVENT_REGISTRATION();
pcer.eventType = PeerCollabEventType.EndPointChanged;
pcer.pInstance = IntPtr.Zero;
//
// Register event with collab
//
int errorCode = UnsafeCollabNativeMethods.PeerCollabRegisterEvent(
m_nameChangedEvent.SafeWaitHandle,
1,
ref pcer,
out m_safeNameChangedEvent);
if (errorCode != 0){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerCollabRegisterEvent returned with errorcode {0}", errorCode);
throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Collab_NameChangedRegFailed), errorCode);
}
}
m_nameChanged += callback;
}
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "AddNameChanged() successful.");
}
//
//
[System.Security.SecurityCritical]
private void RemoveNameChanged(EventHandler callback)
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "RemoveNameChanged() called.");
lock (LockNameChangedEvent){
m_nameChanged -= callback;
if (m_nameChanged == null){
CollaborationHelperFunctions.CleanEventVars(ref m_regNameChangedWaitHandle,
ref m_safeNameChangedEvent,
ref m_nameChangedEvent);
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Clean NameChanged variables successful.");
}
}
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "RemoveNameChanged() successful.");
}
//
//
[System.Security.SecurityCritical]
private void NameChangedCallback(object state, bool timedOut)
{
SafeCollabData eventData = null;
int errorCode = 0;
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "NameChangedCallback() called.");
if (m_Disposed) return;
while (true){
NameChangedEventArgs nameChangedArgs = null;
//
// Get the event data for the fired event
//
try{
lock (LockNameChangedEvent)
{
if (m_safeNameChangedEvent.IsInvalid) return;
errorCode = UnsafeCollabNativeMethods.PeerCollabGetEventData(m_safeNameChangedEvent,
out eventData);
}
if (errorCode == UnsafeCollabReturnCodes.PEER_S_NO_EVENT_DATA)
break;
else if (errorCode != 0){
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerCollabGetEventData returned with errorcode {0}", errorCode);
throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Collab_GetNameChangedDataFailed), errorCode);
}
PEER_COLLAB_EVENT_DATA ped = (PEER_COLLAB_EVENT_DATA)Marshal.PtrToStructure(eventData.DangerousGetHandle(),
typeof(PEER_COLLAB_EVENT_DATA));
if (ped.eventType == PeerCollabEventType.EndPointChanged){
PEER_EVENT_ENDPOINT_CHANGED_DATA epData = ped.endpointChangedData;
PeerEndPoint peerEndPoint = null;
if (epData.pEndPoint != IntPtr.Zero){
PEER_ENDPOINT pe = (PEER_ENDPOINT)Marshal.PtrToStructure(epData.pEndPoint, typeof(PEER_ENDPOINT));
peerEndPoint = CollaborationHelperFunctions.ConvertPEER_ENDPOINTToPeerEndPoint(pe);
}
if ((peerEndPoint != null) && Equals(peerEndPoint)){
PeerContact peerContact = null;
if (epData.pContact != IntPtr.Zero){
PEER_CONTACT pc = (PEER_CONTACT)Marshal.PtrToStructure(epData.pContact, typeof(PEER_CONTACT));
peerContact = CollaborationHelperFunctions.ConvertPEER_CONTACTToPeerContact(pc);
}
nameChangedArgs = new NameChangedEventArgs(peerEndPoint,
peerContact,
peerEndPoint.Name);
}
}
}
finally{
if (eventData != null) eventData.Dispose();
}
//
// Fire the callback with the marshalled event args data
//
if (nameChangedArgs != null){
OnNameChanged(nameChangedArgs);
//
// Change the name with the new name
//
Name = nameChangedArgs.PeerEndPoint.Name;
}
}
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Leaving NameChangedCallback().");
}
protected void OnNameChanged(NameChangedEventArgs nameChangedArgs)
{
EventHandler handlerCopy = m_nameChanged;
if (handlerCopy != null){
if (SynchronizingObject != null && SynchronizingObject.InvokeRequired)
SynchronizingObject.BeginInvoke(handlerCopy, new object[] { this, nameChangedArgs });
else
handlerCopy(this, nameChangedArgs);
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Fired the name changed event callback.");
}
}
public bool Equals(PeerEndPoint other)
{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
//
// Equality means same ipendpoints
//
if (other != null){
return other.EndPoint.Equals(EndPoint);
}
return false;
}
public override bool Equals(object obj)
{
PeerEndPoint comparandPeerEndPoint = obj as PeerEndPoint;
if (comparandPeerEndPoint != null){
return comparandPeerEndPoint.EndPoint.Equals(EndPoint);
}
return false;
}
public new static bool Equals(object objA, object objB)
{
PeerEndPoint comparandPeerEndPoint1 = objA as PeerEndPoint;
PeerEndPoint comparandPeerEndPoint2 = objB as PeerEndPoint;
if ((comparandPeerEndPoint1 != null) && (comparandPeerEndPoint2 != null)){
return comparandPeerEndPoint1.EndPoint.Equals(comparandPeerEndPoint2.EndPoint);
}
return false;
}
public override int GetHashCode()
{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
return EndPoint.GetHashCode();
}
public override string ToString()
{
if (m_Disposed) throw new ObjectDisposedException(this.GetType().FullName);
return m_endPointName;
}
private bool m_Disposed;
//
//
[System.Security.SecurityCritical]
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
//
//
[System.Security.SecurityCritical]
protected virtual void Dispose(bool disposing)
{
if (!m_Disposed){
CollaborationHelperFunctions.CleanEventVars(ref m_regNameChangedWaitHandle,
ref m_safeNameChangedEvent,
ref m_nameChangedEvent);
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Clean NameChanged variables successful.");
}
m_Disposed = true;
}
//
//
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase", Justification = "System.Net.dll is still using pre-v4 security model and needs this demand")]
[System.Security.SecurityCritical]
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter, SerializationFormatter = true)]
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
{
GetObjectData(info, context);
}
///
/// This is made virtual so that derived types can be implemented correctly
///
[SecurityPermission(SecurityAction.LinkDemand, SerializationFormatter = true)]
protected virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("_EndPointName", m_endPointName);
info.AddValue("_EndPoint", m_endPoint);
}
internal void TracePeerEndPoint()
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "Contents of the PeerEndPoint");
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "\tEndPoint: {0}", (EndPoint != null? EndPoint.ToString(): null));
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "\tDescription: {0}", Name);
}
}
///
/// Represents a collection of PeerEndPoints
///
[Serializable]
public class PeerEndPointCollection : Collection, IEquatable
{
internal PeerEndPointCollection() { }
protected override void SetItem(int index, PeerEndPoint item)
{
//
// Null peerendpoints not allowed
//
if (item == null){
throw new ArgumentNullException("item");
}
base.SetItem(index, item);
}
protected override void InsertItem(int index, PeerEndPoint item)
{
//
// Null peerendpoints not allowed
//
if (item == null){
throw new ArgumentNullException("item");
}
base.InsertItem(index, item);
}
public override string ToString()
{
bool first = true;
StringBuilder builder = new StringBuilder();
foreach (PeerEndPoint peerEndPoint in this){
if (!first){
builder.Append(", ");
}
else{
first = false;
}
builder.Append(peerEndPoint.ToString());
}
return builder.ToString();
}
public bool Equals(PeerEndPointCollection other)
{
bool equal = false;
if (other != null){
foreach (PeerEndPoint peerEndPoint1 in other)
foreach (PeerEndPoint peerEndPoint2 in this)
if (!peerEndPoint1.Equals(peerEndPoint2)){
return equal;
}
equal = true;
}
return equal;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- BrowserDefinition.cs
- TaiwanLunisolarCalendar.cs
- VariableQuery.cs
- MetadataArtifactLoaderResource.cs
- SerializationEventsCache.cs
- UserControlParser.cs
- TextLineBreak.cs
- RemotingConfiguration.cs
- TraversalRequest.cs
- ServiceContractListItem.cs
- ToolboxComponentsCreatedEventArgs.cs
- Verify.cs
- DataControlFieldCell.cs
- DrawingCollection.cs
- SerTrace.cs
- BindingBase.cs
- ScriptControlManager.cs
- ExtendedProperty.cs
- RegexBoyerMoore.cs
- PDBReader.cs
- ProviderUtil.cs
- COM2DataTypeToManagedDataTypeConverter.cs
- EdmItemError.cs
- MessageSecurityProtocolFactory.cs
- BufferedStream.cs
- ClientFormsAuthenticationMembershipProvider.cs
- EventWaitHandleSecurity.cs
- StronglyTypedResourceBuilder.cs
- MenuItem.cs
- CornerRadius.cs
- ReadOnlyObservableCollection.cs
- SmiMetaDataProperty.cs
- ContentPlaceHolder.cs
- ShortcutKeysEditor.cs
- DataControlFieldCollection.cs
- SamlSecurityTokenAuthenticator.cs
- streamingZipPartStream.cs
- AuthorizationSection.cs
- TypeSystem.cs
- InputProviderSite.cs
- ResourceDescriptionAttribute.cs
- TextComposition.cs
- OleDbReferenceCollection.cs
- PolicyUtility.cs
- CngKeyBlobFormat.cs
- ConfigurationLockCollection.cs
- Transform3DGroup.cs
- NativeMethods.cs
- SecurityDocument.cs
- WebColorConverter.cs
- _ProxyRegBlob.cs
- RawKeyboardInputReport.cs
- CheckBoxAutomationPeer.cs
- OperationResponse.cs
- PieceDirectory.cs
- ContextTokenTypeConverter.cs
- AlphabeticalEnumConverter.cs
- GenericUI.cs
- cookieexception.cs
- RegexRunnerFactory.cs
- Catch.cs
- Font.cs
- SoapAttributeAttribute.cs
- DateTimeValueSerializer.cs
- BasePattern.cs
- HtmlTableCellCollection.cs
- MouseGestureValueSerializer.cs
- Interfaces.cs
- DBSqlParserTableCollection.cs
- DynamicMethod.cs
- BulletedList.cs
- RadialGradientBrush.cs
- ModelVisual3D.cs
- SystemThemeKey.cs
- Parsers.cs
- ModifiableIteratorCollection.cs
- XPathNodeList.cs
- XmlDataImplementation.cs
- ColorPalette.cs
- ObjectListField.cs
- TextEffect.cs
- PowerModeChangedEventArgs.cs
- ChannelEndpointElementCollection.cs
- ResourceDisplayNameAttribute.cs
- DataComponentMethodGenerator.cs
- WorkflowRuntimeServiceElement.cs
- ToolboxItemLoader.cs
- SaveFileDialog.cs
- HttpCapabilitiesBase.cs
- CookielessHelper.cs
- SQLInt64.cs
- CompositeActivityDesigner.cs
- EndpointDispatcher.cs
- HwndHost.cs
- MemoryMappedFile.cs
- TempFiles.cs
- SwitchDesigner.xaml.cs
- PageThemeParser.cs
- UpdateProgress.cs
- CommandHelper.cs