/// <summary>
/// Availables the service providers changed event handler.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="ServiceProvidersChangedEventArgs"/> instance containing the event data.</param>
protected virtual void AvailableServiceProvidersChangedEventHandler(object sender, ServiceProvidersChangedEventArgs e)
{
if (this.InvokeRequired)
{
EventHandler <ServiceProvidersChangedEventArgs> d = new EventHandler <ServiceProvidersChangedEventArgs>(AvailableServiceProvidersChangedEventHandler);
((ConnectControl)d.Target).Invoke(d, sender, e);
return;
}
ListSpecialized <ServiceProvider> providers = e.ServiceProviders;
List <ListViewItem> removableItems = new List <ListViewItem>();
// kidobom azokat az elemeket a listviewból, amelyek már nincsennek
foreach (ListViewItem item in lvServices.Items)
{
ServiceProvider savedProvider = item.Tag as ServiceProvider;
if (!providers.Contains(savedProvider))
{
removableItems.Add(item);
}
}
removableItems.ForEach(i => i.Remove());
removableItems.Clear();
// felveszem azokat, akik még nincsennek a listában
IEnumeratorSpecialized <ServiceProvider> spEnum = providers.GetEnumerator();
while (spEnum.MoveNext())
{
ServiceProvider provider = spEnum.Current;
if (!NetworkManager.Instance.Localhost.Equals(provider.NetworkPeer))
{
bool found = false;
foreach (ListViewItem item in lvServices.Items)
{
ServiceProvider savedProvider = item.Tag as ServiceProvider;
if (savedProvider.Equals(provider))
{
found = true;
break;
}
}
if (!found)
{
ListViewItem item = new ListViewItem(provider.NetworkPeer.Id);
item.Tag = provider;
lvServices.Items.Add(item);
}
}
}
lvServices.Sort();
lvServices_SelectedIndexChanged(null, null);
}
private static void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
{
string name = args.LoadedAssembly.GetName().Name;
lock (mAssemblyNameVsTypeKey)
{
if (mAssemblyNameVsTypeKey.ContainsKey(name))
{
ListSpecialized <TypeKey> list = mAssemblyNameVsTypeKey[name];
IEnumeratorSpecialized <TypeKey> iterator = list.GetEnumerator();
while (iterator.MoveNext())
{
if (iterator.Current.TypeLookupMode != TypeLookupModeEnum.AllowExactVersions)
{
mTypeKeyVsType.Remove(iterator.Current);
iterator.Remove();
}
}
}
}
}
/// <summary>
/// Unsubscribe for keys.
/// </summary>
/// <param name="subscription">The subscription.</param>
/// <param name="e">The decimal.</param>
public void UnsubscribeForKeys(KeysSubscription subscription, EventHandler <SubscribedKeyPressEventArgs> e)
{
if (subscription == null)
{
ThrowHelper.ThrowArgumentNullException("subscription");
}
if (e == null)
{
ThrowHelper.ThrowArgumentNullException("e");
}
lock (mKeysSubscriptions)
{
if (mKeysSubscriptions.ContainsKey(subscription))
{
ListSpecialized <EventHandler <SubscribedKeyPressEventArgs> > list = mKeysSubscriptions[subscription];
IEnumeratorSpecialized <EventHandler <SubscribedKeyPressEventArgs> > en = list.GetEnumerator();
while (en.MoveNext())
{
if (en.Current.Method.Equals(e.Method) && en.Current.Target.Equals(e.Target))
{
en.Remove();
break;
}
}
if (list.Count == 0)
{
mKeysSubscriptions.Remove(subscription);
}
}
}
}
/// <summary>
/// Gets the enumerator.
/// </summary>
/// <returns>Enumerator of generic items</returns>
public override IEnumeratorSpecialized <T> GetEnumerator()
{
DoDisposeCheck();
return((IEnumeratorSpecialized <T>)mInnerList.GetEnumerator());
}
public void Generate(string outputDir)
{
if (outputDir == null)
{
ThrowHelper.ThrowArgumentNullException("outputDir");
}
if (!mIsCollected)
{
// reset fields
mServiceMethods.Clear();
mClientMethods.Clear();
mNeutralMethods.Clear();
mNeutralProperties.Clear();
mNeutralEvents.Clear();
// collect methods
CollectMethods(ContractType);
mIsCollected = true;
}
FileStream fs = null;
try
{
TypeDescriptor descriptor = new TypeDescriptor(ContractType);
{
DirectoryInfo outDir = new DirectoryInfo(outputDir);
if (!outDir.Exists)
{
outDir.Create();
}
}
// generate service class(es)
bool writeOverride = false;
if (mWellKnownObjectMode == WellKnownObjectModeEnum.PerSession && mClientMethods.Count > 0)
{
// write abstract class
FileInfo abstractFile = new FileInfo(Path.Combine(outputDir, String.Format("{0}.cs", descriptor.TypeNameServiceAbstract)));
using (fs = new FileStream(abstractFile.FullName, FileMode.Create, FileAccess.Write, FileShare.Read))
{
GeneratorBase.WriteAbstractProxyClassHeader(ContractType, true, fs);
GeneratorBase.WriteEvents(mNeutralEvents, fs);
GeneratorBase.WriteProxyContructor(false, descriptor.TypeNameServiceAbstract, fs);
GeneratorBase.WriteAbstractProperties(mNeutralProperties, fs);
GeneratorBase.WriteAbstractMethods(mServiceMethods, fs);
GeneratorBase.WriteAbstractMethods(mNeutralMethods, fs);
IEnumerator <MethodComparator> iterator = mClientMethods.GetEnumerator();
while (iterator.MoveNext())
{
MethodComparator mc = iterator.Current;
ServiceSideGenerator.GenerateServiceMethod(ContractType, mc.Method, fs);
}
GeneratorBase.WriteEndClass(fs);
}
writeOverride = true;
}
{
FileInfo implFile = new FileInfo(Path.Combine(outputDir, String.Format("{0}.cs", descriptor.TypeNameServiceImpl)));
using (fs = new FileStream(implFile.FullName, FileMode.Create, FileAccess.Write, FileShare.Read))
{
String baseType = string.Empty;
if (mWellKnownObjectMode == WellKnownObjectModeEnum.PerSession)
{
if (mClientMethods.Count > 0)
{
baseType = descriptor.TypeFullNameServiceAbstract;
}
else
{
baseType = typeof(ProxyBase).FullName;
}
}
GeneratorBase.WriteImplementationClassHeader(ContractType, baseType, true, fs);
if (!writeOverride)
{
GeneratorBase.WriteEvents(mNeutralEvents, fs);
}
if (mWellKnownObjectMode == WellKnownObjectModeEnum.PerSession)
{
GeneratorBase.WriteProxyContructor(true, descriptor.TypeNameServiceImpl, fs);
}
else
{
GeneratorBase.WriteEmptyContructor(true, descriptor.TypeNameServiceImpl, fs);
}
GeneratorBase.WriteProperties(mNeutralProperties, writeOverride, fs);
GeneratorBase.WriteMethods(mServiceMethods, writeOverride, fs);
GeneratorBase.WriteMethods(mNeutralMethods, writeOverride, fs);
GeneratorBase.WriteEndClass(fs);
}
}
// generate client class(es)
writeOverride = false;
bool disposeDetected = typeof(IDisposable).IsAssignableFrom(ContractType) && mNeutralMethods.Count == 1;
if ((mClientMethods.Count > 0 || mNeutralMethods.Count > 0) && !disposeDetected)
{
// write abstract class
FileInfo abstractFile = new FileInfo(Path.Combine(outputDir, String.Format("{0}.cs", descriptor.TypeNameClientAbstract)));
using (fs = new FileStream(abstractFile.FullName, FileMode.Create, FileAccess.Write, FileShare.Read))
{
GeneratorBase.WriteAbstractProxyClassHeader(ContractType, false, fs);
GeneratorBase.WriteEvents(mNeutralEvents, fs);
GeneratorBase.WriteProxyContructor(false, descriptor.TypeNameClientAbstract, fs);
GeneratorBase.WriteAbstractProperties(mNeutralProperties, fs);
GeneratorBase.WriteAbstractMethods(mClientMethods, fs);
GeneratorBase.WriteAbstractMethods(mNeutralMethods, fs);
IEnumerator <MethodComparator> iterator = mServiceMethods.GetEnumerator();
while (iterator.MoveNext())
{
MethodComparator mc = iterator.Current;
ClientSideGenerator.GenerateServiceMethod(ContractType, mc.Method, fs);
}
GeneratorBase.WriteEndClass(fs);
}
writeOverride = true;
}
{
FileInfo implFile = new FileInfo(Path.Combine(outputDir, String.Format("{0}.cs", descriptor.TypeNameClientImpl)));
using (fs = new FileStream(implFile.FullName, FileMode.Create, FileAccess.Write, FileShare.Read))
{
String baseType = typeof(ProxyBase).FullName;
if ((mClientMethods.Count > 0 || mNeutralMethods.Count > 0) && !disposeDetected)
{
baseType = descriptor.TypeFullNameClientAbstract;
}
GeneratorBase.WriteImplementationClassHeader(ContractType, baseType, false, fs);
if (!writeOverride)
{
GeneratorBase.WriteEvents(mNeutralEvents, fs);
}
GeneratorBase.WriteProxyContructor(true, descriptor.TypeNameClientImpl, fs);
GeneratorBase.WriteProperties(mNeutralProperties, writeOverride, fs);
GeneratorBase.WriteMethods(mClientMethods, writeOverride, fs);
if (disposeDetected)
{
// ha az IDisposable interface implementálva van, akkor a dispose() metódust nem szabad generálni kliens oldalon, mert a ProxyBase-ben már benne van
IEnumeratorSpecialized <MethodComparator> iterator = mNeutralMethods.GetEnumerator();
while (iterator.MoveNext())
{
MethodComparator mc = iterator.Current;
if (mc.Method.Name.Equals("Dispose") && mc.Method.GetParameters().Length == 0)
{
iterator.Remove();
break;
}
}
}
GeneratorBase.WriteMethods(mNeutralMethods, writeOverride, fs);
if (!((mClientMethods.Count > 0 || mNeutralMethods.Count > 0) && !disposeDetected))
{
IEnumerator <MethodComparator> iterator = mServiceMethods.GetEnumerator();
while (iterator.MoveNext())
{
MethodComparator mc = iterator.Current;
ClientSideGenerator.GenerateServiceMethod(ContractType, mc.Method, fs);
}
}
GeneratorBase.WriteEndClass(fs);
}
}
}
catch (Exception ex)
{
throw new ProxyGenerationFailedException("Failed to generate proxy classes.", ex);
}
}