/// <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); } }