That helped. Between you and a MS tech, I have been
successfull establishing more impervious connections using
both IPC and a modified TCP (with bindTo and machineName).
Both options work great between two test applications. They
fail miserably, with the same connection loss, between the
"real" application and the service. Maybe I'm close to a
solution, and perhaps not.

"Doug Semler" wrote:

ANSWER: On the localhost machine, we have to use IPC. The callbacks channel
had to be created in code, but the remoting proxy channel can be configured
in the config file. A key piece was the attribute
authorizedGroup="Everyone", required on both IPC channels.
Since we have other identical remoting connections to other machines, a
TrackingHandler was required to search the ChannelData when an object was
being marshaled and remove the IPC channel from the list when the target is
on a different machine. That is probably the most complicated part. The
rest is very straightforward.

/// <summary>
/// The TrackingHandler is used for customizing a Remoting connection.
/// This one removes references to any IPC channel unless the connecting
/// object has been registered to allow an IPC connection.
/// </summary>
public class IpcTrackingHandler : ITrackingHandler
{
List<object> allowInIpcChannelList = new List<object>();

public void AllowThisInIpcChannel( object o )
{
allowInIpcChannelList.Add(o);
}

// Called when the tracked object is marshaled.
public void MarshaledObject( Object obj, ObjRef objRef )
{
if (!allowInIpcChannelList.Contains(obj) && objRef.ChannelInfo !=
null)
{
List<object> replacementChannelData = new List<object>();
// Copy ChannelData except for any IPC store
foreach (object data in objRef.ChannelInfo.ChannelData)
{
bool okToAdd = true;
if (data is ChannelDataStore)
{
foreach (string uri in
((ChannelDataStore)data).ChannelUris)
{
if (uri.StartsWith("ipc"))
{
okToAdd = false;
break;
}
}
}
if (okToAdd)
replacementChannelData.Add(data);
}
objRef.ChannelInfo.ChannelData = replacementChannelData.ToArray();
}
}

// Called when the tracked object is unmarshaled.
public void UnmarshaledObject( Object obj, ObjRef objRef ) { }

// Called when the tracked object is disconnected.
public void DisconnectedObject( Object obj ) { }
}

"Doug Semler" <dougsemler (AT) gmail (DOT) com> wrote in
news:#yjh9KhAIHA.4844 (AT) TK2MSFTNGP02 (DOT) phx.gbl:



I used option #2:

http://www.codeproject.com/csharp/RemotingAndEvents.asp

Works great under high volumes too.