/// <summary> /// Erzeugt ein neue Zustandsinformation. /// </summary> /// <param name="pipeline">Die zugehörige Gesamtliste aller Aktionen gleicher Art.</param> /// <param name="location">Der Ursprung für die angegebene Quellgruppe.</param> /// <param name="group">Die neue Quellgruppe.</param> /// <returns>Die gewünschte Information.</returns> /// <exception cref="ArgumentNullException">Es wurde kein Graph übergeben.</exception> internal static TuneToken Create(ActionPipeline <TuneToken> pipeline, GroupLocation location, SourceGroup group) { // Create new var token = new TuneToken(pipeline, location, group); // Configure IDVBTuningSpace2 tuningSpace; Action <ILocator> initializer; switch (pipeline.Graph.DVBType) { case DVBSystemType.Terrestrial: tuningSpace = token.PrepareTerrestrial(out initializer); break; case DVBSystemType.Satellite: tuningSpace = token.PrepareSatellite(out initializer); break; case DVBSystemType.Cable: tuningSpace = token.PrepareCable(out initializer); break; default: throw new NotImplementedException(pipeline.Graph.DVBType.ToString()); } // With cleanup try { // Create a new tune request token.CreateTuneRequest(tuningSpace, initializer); } finally { // No longer used BDAEnvironment.Release(ref tuningSpace); } // Report return(token); }
/// <summary> /// Erzeugt ein neue Zustandsinformation. /// </summary> /// <param name="pipeline">Die zugehörige Gesamtliste aller Aktionen gleicher Art.</param> /// <returns>Die gewünschte Information.</returns> /// <exception cref="ArgumentNullException">Es wurde kein Graph übergeben.</exception> internal static SignalToken Create(ActionPipeline <SignalToken> pipeline) { // Status to use BDASignalStatus status = null; int? strength = null; // See if something is provided var tuner = pipeline.Graph.TunerFilter; if (tuner != null) { // Ask network provider for signal information using (var filter = pipeline.Graph.NetworkProvider.MarshalToManaged()) try { // Attach to the primary interface and read the strength if provided - may be more current than the signal statistics var tunerInterface = filter.Object as ITuner; if (tunerInterface != null) { strength = tunerInterface.SignalStrength; } } catch { // Just ignore any error } // Attach to interface var statistics = tuner.GetSignalStatistics(); if (statistics != null) { try { // Report status = new BDASignalStatus(statistics.SignalLocked != 0, statistics.SignalStrength, statistics.SignalQuality / 100.0); } catch { // Just ignore any error } finally { // Back to COM BDAEnvironment.Release(ref statistics); } } } // Create new return(new SignalToken(pipeline, status, strength)); }
/// <summary> /// Beendet die Anmeldung endfültig. /// </summary> public void Dispose() { // Check registration if (m_Register.HasValue) { // Unregister m_ROT.Revoke(m_Register.Value); // Forget m_Register = null; } // Forget BDAEnvironment.Release(ref m_ROT); }
/// <summary> /// Erzeugt eine neue Referenz unter Angabe eines eindeutigen Namens. /// </summary> /// <typeparam name="T">Die Art des verwalteten Objektes.</typeparam> /// <param name="moniker">Der eindeutige Namen zum Objekt.</param> /// <returns>Die gewünschte Referenz.</returns> public static TypedComIdentity <T> Create <T>(string moniker) where T : class { // Create var instance = Marshal.BindToMoniker(moniker); try { // Report return(Create((T)instance)); } finally { // Cleanup BDAEnvironment.Release(ref instance); } }
/// <summary> /// Erzeugt eine neue Anmeldung. /// </summary> /// <param name="comObject">Ein beliebiges Objekt.</param> /// <exception cref="ArgumentNullException">Es wurde kein Objekt angegeben.</exception> public ROTRegister(object comObject) { // Validate if (comObject == null) { throw new ArgumentNullException("comObject"); } // Attach to ROT if (GetRunningObjectTable(0, out m_ROT) < 0) { return; } // Attach to COM interface IntPtr unk = Marshal.GetIUnknownForObject(comObject); try { // Create the name string moniker = string.Format("FilterGraph {0:x8} pid {1:x8}", unk.ToInt32(), Process.GetCurrentProcess().Id); // Create the item moniker for the format comTypes.IMoniker mon; if (CreateItemMoniker("!", moniker, out mon) >= 0) { try { // Register m_Register = m_ROT.Register(1, comObject, mon); } finally { // Back to COM BDAEnvironment.Release(ref mon); } } } finally { // Back to COM BDAEnvironment.Release(ref unk); } }
/// <summary> /// Ermittelt über die COM Schnittstelle eines Feldelementes eine .NET Schnittstelle. /// </summary> /// <typeparam name="T">Die gewünschte Art der .NET Schnittstelle.</typeparam> /// <param name="index">Die 0-basierte laufende Nummer des Elementes.</param> /// <returns>Das zugehörige .NET Objekt.</returns> public T GetObject <T>(int index) { // Load var instance = GetObject(index); try { // Change type return((T)instance); } catch { // Cleanup BDAEnvironment.Release(ref instance); // Forward throw; } }
/// <summary> /// Erzeugt eine .NET Schnittstelle zum verwalteten COM Objekt. /// </summary> /// <returns>Das gewünschte Objekt für den .NET Zugriff</returns> public Incarnation MarshalToManaged() { // Create var instance = Marshal.GetObjectForIUnknown(Interface); try { // Just change type type return(new Incarnation((T)instance)); } catch { // Cleanup BDAEnvironment.Release(ref instance); // Forward throw; } }
/// <summary> /// Erzeugt die eigentliche Anfrage zum Wechseln der Quellgruppe. /// </summary> /// <param name="tuningSpace">Der zu verwendende Namensraum.</param> /// <param name="initializer">Methode zur Übertragung der aktuellen Quellgruppenparameter.</param> private void CreateTuneRequest(IDVBTuningSpace2 tuningSpace, Action <ILocator> initializer) { // Create from tuning space m_Request = tuningSpace.CreateTuneRequest(); // Reset internally - just in case m_Request.ONID = -1; m_Request.TSID = -1; m_Request.SID = -1; // Attach to the default locator var @default = tuningSpace.DefaultLocator; try { // Clone the default locator var locator = @default.Clone(); try { // Set it up initializer?.Invoke(locator); // Attach locator m_Request.Locator = locator; } finally { // Detach from clone BDAEnvironment.Release(ref locator); } } finally { // Detach BDAEnvironment.Release(ref @default); } }
/// <summary> /// Bereitet die internen Strukturen für die Konfiguration einer Quellgruppe für den /// Satellitenempfang vor. /// </summary> /// <param name="initializer">Methode zur Übernahme der Parameter der Quellgruppe.</param> /// <returns>Ein neuer Namensraum.</returns> private IDVBTuningSpace2 PrepareSatellite(out Action <ILocator> initializer) { // Get native types var location = GroupLocation as SatelliteLocation; var group = SourceGroup as SatelliteGroup; // Create DiSEqC message if (location != null) { if (group != null) { DiSEqCMessage = StandardDiSEqC.FromSourceGroup(group, location); } } // Create tuning space var space = Activator.CreateInstance(Type.GetTypeFromCLSID(DVBSTuningSpaceClassIdentifier)); try { // Change type var tuningSpace = (IDVBSTuningSpace)space; // Configure tuningSpace.UniqueName = "DVBNET Satellite"; tuningSpace.FriendlyName = "DVB.NET Satellite Tuning Space"; tuningSpace.NetworkType = "{FA4B375A-45B4-4D45-8440-263957B11623}"; tuningSpace.SystemType = DVBSystemType.Satellite; // Configure location if (location != null) { // Configure tuningSpace.LNBSwitch = checked ((int)location.SwitchFrequency); tuningSpace.HighOscillator = checked ((int)location.Frequency2); tuningSpace.LowOscillator = checked ((int)location.Frequency1); tuningSpace.SpectralInversion = SpectralInversion.Automatic; tuningSpace.FrequencyMapping = string.Empty; tuningSpace.InputRange = string.Empty; tuningSpace.NetworkID = -1; } // Create locator var locator = Activator.CreateInstance(Type.GetTypeFromCLSID(DVBSLocatorClassIdentifier)); try { // Configure group if (group == null) { initializer = null; } else { initializer = clone => { // Change type var dvbs = (IDVBSLocator)clone; // Configure dvbs.Modulation = group.UsesS2Modulation ? ModulationType.VSB8 : ModulationType.QPSK; dvbs.SymbolRate = checked ((int)(group.SymbolRate / 1000)); dvbs.CarrierFrequency = checked ((int)group.Frequency); dvbs.InnerFECRate = BinaryConvolutionCodeRate.NotSet; dvbs.OuterFECRate = BinaryConvolutionCodeRate.NotSet; dvbs.SignalPolarisation = Polarisation.NotSet; dvbs.WestPosition = group.IsWestPosition; dvbs.OuterFEC = FECMethod.NotSet; dvbs.InnerFEC = FECMethod.NotSet; dvbs.OrbitalPosition = -1; dvbs.Elevation = -1; dvbs.Azimuth = 0; // Set polarisation switch (group.Polarization) { case Polarizations.Horizontal: dvbs.SignalPolarisation = Polarisation.Horizontal; break; case Polarizations.Vertical: dvbs.SignalPolarisation = Polarisation.Vertical; break; } // Set rate switch (group.InnerFEC) { case InnerForwardErrorCorrectionModes.Conv1_2: dvbs.InnerFEC = FECMethod.Viterbi; dvbs.InnerFECRate = BinaryConvolutionCodeRate.Rate1_2; break; case InnerForwardErrorCorrectionModes.Conv2_3: dvbs.InnerFEC = FECMethod.Viterbi; dvbs.InnerFECRate = BinaryConvolutionCodeRate.Rate2_3; break; case InnerForwardErrorCorrectionModes.Conv3_4: dvbs.InnerFEC = FECMethod.Viterbi; dvbs.InnerFECRate = BinaryConvolutionCodeRate.Rate3_4; break; case InnerForwardErrorCorrectionModes.Conv3_5: dvbs.InnerFEC = FECMethod.Viterbi; dvbs.InnerFECRate = BinaryConvolutionCodeRate.Rate3_5; break; case InnerForwardErrorCorrectionModes.Conv4_5: dvbs.InnerFEC = FECMethod.Viterbi; dvbs.InnerFECRate = BinaryConvolutionCodeRate.Rate4_5; break; case InnerForwardErrorCorrectionModes.Conv5_6: dvbs.InnerFEC = FECMethod.Viterbi; dvbs.InnerFECRate = BinaryConvolutionCodeRate.Rate5_6; break; case InnerForwardErrorCorrectionModes.Conv7_8: dvbs.InnerFEC = FECMethod.Viterbi; dvbs.InnerFECRate = BinaryConvolutionCodeRate.Rate7_8; break; case InnerForwardErrorCorrectionModes.Conv8_9: dvbs.InnerFEC = FECMethod.Viterbi; dvbs.InnerFECRate = BinaryConvolutionCodeRate.Rate8_9; break; case InnerForwardErrorCorrectionModes.Conv9_10: dvbs.InnerFEC = FECMethod.Viterbi; dvbs.InnerFECRate = BinaryConvolutionCodeRate.Rate9_10; break; } } }; // Change type - actually test it tuningSpace.DefaultLocator = (ILocator)locator; } finally { // Cleanup BDAEnvironment.Release(ref locator); } // Report return((IDVBTuningSpace2)tuningSpace); } catch { // Cleanup BDAEnvironment.Release(ref space); // Forward throw; } }
/// <summary> /// Bereitet die internen Strukturen für die Konfiguration einer Quellgruppe für den /// Antennenempfang vor. /// </summary> /// <param name="initializer">Methode zur Übernahme der Parameter der Quellgruppe.</param> /// <returns>Der zu verwendende Namensraum.</returns> private IDVBTuningSpace2 PrepareTerrestrial(out Action <ILocator> initializer) { // Create tuning space var space = Activator.CreateInstance(Type.GetTypeFromCLSID(DVBTTuningSpaceClassIdentifier)); try { // Remember var tuningSpace = (IDVBTuningSpace2)space; // Configure tuningSpace.UniqueName = "DVBNET Terrestrial"; tuningSpace.FriendlyName = "DVB.NET Terrestrial Tuning Space"; tuningSpace.NetworkType = "{216C62DF-6D7F-4E9A-8571-05F14EDB766A}"; tuningSpace.SystemType = DVBSystemType.Terrestrial; // Create locator var locator = Activator.CreateInstance(Type.GetTypeFromCLSID(DVBTLocatorClassIdentifier)); try { // See if we are tuning var group = SourceGroup as TerrestrialGroup; if (group == null) { initializer = null; } else { initializer = clone => { // Change type var dvbt = (IDVBTLocator)clone; // Configure dvbt.LPInnerFECRate = BinaryConvolutionCodeRate.NotSet; dvbt.InnerFECRate = BinaryConvolutionCodeRate.NotSet; dvbt.OuterFECRate = BinaryConvolutionCodeRate.NotSet; dvbt.CarrierFrequency = (int)group.Frequency; dvbt.Modulation = ModulationType.NotSet; dvbt.HAlpha = HierarchyAlpha.NotSet; dvbt.Mode = TransmissionMode.NotSet; dvbt.LPInnerFEC = FECMethod.NotSet; dvbt.Guard = GuardInterval.NotSet; dvbt.InnerFEC = FECMethod.NotSet; dvbt.OtherFrequencyInUse = false; dvbt.OuterFEC = FECMethod.NotSet; dvbt.SymbolRate = -1; dvbt.Bandwidth = -1; // Check bandwidth switch (group.Bandwidth) { case Bandwidths.Six: dvbt.Bandwidth = 6; break; case Bandwidths.Seven: dvbt.Bandwidth = 7; break; case Bandwidths.Eight: dvbt.Bandwidth = 8; break; } } }; // Remember - and test the locator type tuningSpace.DefaultLocator = (ILocator)locator; } finally { // Cleanup BDAEnvironment.Release(ref locator); } // Report return(tuningSpace); } catch { // Cleanup BDAEnvironment.Release(ref space); // Forward throw; } }
/// <summary> /// Bereitet die internen Strukturen für die Konfiguration einer Quellgruppe für den /// Kabelempfang vor. /// </summary> /// <param name="initializer">Methode zur Übernahme der Parameter der Quellgruppe.</param> /// <returns>Der zu verwendende Namensraum.</returns> private IDVBTuningSpace2 PrepareCable(out Action <ILocator> initializer) { // Create tuning space var space = Activator.CreateInstance(Type.GetTypeFromCLSID(DVBCTuningSpaceClassIdentifier)); try { // Remember var tuningSpace = (IDVBTuningSpace2)space; // Configure tuningSpace.UniqueName = "DVBNET Cable"; tuningSpace.FriendlyName = "DVB.NET Cable Tuning Space"; tuningSpace.NetworkType = "{DC0C0FE7-0485-4266-B93F-68FBF80ED834}"; tuningSpace.SystemType = DVBSystemType.Cable; // Create locator var locator = Activator.CreateInstance(Type.GetTypeFromCLSID(DVBCLocatorClassIdentifier)); try { // Check group var group = SourceGroup as CableGroup; if (group == null) { initializer = null; } else { initializer = clone => { // Change type var dvbc = (IDVBCLocator)clone; // Configure dvbc.SymbolRate = checked ((int)(group.SymbolRate / 1000)); dvbc.CarrierFrequency = checked ((int)group.Frequency); dvbc.InnerFECRate = BinaryConvolutionCodeRate.NotSet; dvbc.OuterFECRate = BinaryConvolutionCodeRate.NotSet; dvbc.Modulation = ModulationType.NotSet; dvbc.InnerFEC = FECMethod.NotSet; dvbc.OuterFEC = FECMethod.NotSet; // Check modulation switch (group.Modulation) { case CableModulations.QAM16: dvbc.Modulation = ModulationType.QAM16; break; case CableModulations.QAM32: dvbc.Modulation = ModulationType.QAM32; break; case CableModulations.QAM64: dvbc.Modulation = ModulationType.QAM64; break; case CableModulations.QAM128: dvbc.Modulation = ModulationType.QAM128; break; case CableModulations.QAM256: dvbc.Modulation = ModulationType.QAM256; break; } // See if tuner is available var tuner = Pipeline.Graph.TunerFilter; if (tuner != null) { // Attach to the demodulator interface var demodulator = tuner.GetDigitalDemodulator(); if (demodulator != null) { try { // Strange API needs helpers - sets values using pointers var inversion = SpectralInversion.NotSet; // Check spectral inversion switch (group.SpectrumInversion) { case SpectrumInversions.Auto: inversion = SpectralInversion.Automatic; break; case SpectrumInversions.Off: inversion = SpectralInversion.Normal; break; case SpectrumInversions.On: inversion = SpectralInversion.Inverted; break; } // Set inversion demodulator.SetSpectralInversion(ref inversion); } finally { // Cleanup BDAEnvironment.Release(ref demodulator); } } } } }; // Remember - acutally test the type tuningSpace.DefaultLocator = (ILocator)locator; } finally { // Cleanup BDAEnvironment.Release(ref locator); } // Report return(tuningSpace); } catch { // Cleanup BDAEnvironment.Release(ref space); // Forward throw; } }
/// <summary> /// Erzeugt einen Graphen und startet ihn. /// </summary> /// <param name="location">Der Ursprung, über den die Quellgruppe empfangen wird.</param> /// <param name="group">Die gewünschte Quellgruppe.</param> /// <exception cref="ArgumentException">Es wurden nicht alle Parameter gesetzt.</exception> public void Create(GroupLocation location, SourceGroup group) { // Get rid of it Destroy(); // Create new graph builder var graph = Activator.CreateInstance(Type.GetTypeFromCLSID(BDAEnvironment.GraphBuilderClassIdentifier)); try { // Convert interface m_Graph = (IMediaFilter)graph; } catch { // Cleanup BDAEnvironment.Release(ref graph); // Forward throw; } // See if we should register the graph m_ExternalRegistration = BDASettings.RegisterBDAGRaph(m_Graph, false); // Attach to alternate interface var builder = (IGraphBuilder)m_Graph; // Check log var logFile = BDASettings.BDALogPath; if (logFile != null) { // Open path m_LogFile = new FileStream(logFile.FullName, FileMode.Create, FileAccess.Write, FileShare.Read); // Enable logging on graph builder builder.SetLogFile(m_LogFile.SafeFileHandle); } // Start with network provider NetworkProvider = AddFilter("Network Provider", BDAEnvironment.GetNetworkProviderMoniker(DVBType)); // Initialize provider Tune(location, group); // Always create the tuner if (TunerInformation != null) { TunerFilter = AddFilter("Tuner", TunerInformation); } else { throw new ArgumentException(Properties.Resources.Exception_MissingTuner, "Tuner"); } // Optionally create capture if (CaptureInformation != null) { CaptureFilter = AddFilter("Capture", CaptureInformation); } // Add additional filter foreach (var additionalFilter in AdditionalFilterInformations) { if (additionalFilter == null) { throw new ArgumentNullException("AdditionalFilters"); } else { AdditionalFilters.Add(AddFilter(additionalFilter.DisplayName, additionalFilter)); } } // Connect network provider to streaming instance Connect(NetworkProvider, CaptureFilter ?? TunerFilter); // Initialize provider Tune(location, group); // Create the primary filter and add it AddFilter("TS", TransportStreamAnalyser = new InputFilter()); // Connect device output for analysis Connect(CaptureFilter ?? TunerFilter, TransportStreamAnalyser); // Create the demultiplexer - needed to keep the infrastructure alive using (var demux = AddFilter("TIF", BDAEnvironment.MicrosoftDemultiplexerMoniker)) { // Connect to the dedicated pin of our analyser TransportStreamAnalyser.DataManager.TIFConnector.Connect(demux, BDAEnvironment.TransportStreamMediaType1); // Pins to remove var remove = new List <string>(); // Prepare the demultiplexer pins demux.InspectAllPins(pin => { // See if this is the SI pin bool isSectionPin = false; pin.InspectAllMediaTypes(type => { // Check major if (!type.MajorType.Equals(BDAEnvironment.DataFormatTypeSections)) { return(true); } // Check minor isSectionPin = type.SubType.Equals(BDAEnvironment.DataFormatSubtypeSI); // Report return(!isSectionPin); }); // Check the mode if (isSectionPin) { // Connect using (var comPin = ComIdentity.Create(pin)) builder.Render(comPin.Interface); // Load connection data IntPtr tifIn = IntPtr.Zero; if (pin.ConnectedTo(ref tifIn) < 0) { throw new InvalidOperationException(Properties.Resources.Exception_TIF); } // Reconstruct var tifPin = Marshal.GetObjectForIUnknown(tifIn); try { // Request pin context var info = new PinInfo(); ((IPin)tifPin).QueryPinInfo(ref info); // Request from pin m_TIF = info.GetAndDisposeFilter(); } finally { // Cleanup BDAEnvironment.Release(ref tifPin); } } else if (pin.QueryDirection() == PinDirection.Output) { // Prepare to kill remove.Add(pin.QueryId()); } }); // Prepare to remove all unconnected pins if (remove.Count > 0) { using (var demuxInstance = demux.MarshalToManaged()) { // Change type var mpeg2 = (IMpeg2Demultiplexer)demuxInstance.Object; // Remove all foreach (var id in remove) { mpeg2.DeleteOutputPin(id); } } } } // Install the PMT watchdog TransportStreamAnalyser.DataManager.TSParser.PMTFound += ProcessPMT; }
/// <summary> /// Wählt eine neue Quellgruppe aus. /// </summary> /// <param name="location">Der Ursprung, über den die Quellgruppe empfangen wird.</param> /// <param name="group">Die gewünschte Quellgruppe.</param> /// <exception cref="NotSupportedException">Der Graph wurde noch nicht erzeugt.</exception> public void Tune(GroupLocation location, SourceGroup group) { // Validate if (NetworkProvider == null) { throw new NotSupportedException(Properties.Resources.Exception_NotStarted); } // PAT wait configuration - will use 1/10sec per retry var patRetries = Configuration.MinimumPATCountWaitTime; var patsExpected = Configuration.MinimumPATCount; // Attach to helper var analyser = TransportStreamAnalyser; var manager = (analyser == null) ? null : analyser.DataManager; var parser = (manager == null) ? null : manager.TSParser; // May want to retry at least four times for (var outerRetry = 4; outerRetry-- > 0; patsExpected += 5, patRetries += 25) { // Always stop raw dump if (manager != null) { manager.StopDump(); } // Report if (BDASettings.BDATraceSwitch.Enabled) { Trace.WriteLine(string.Format(Properties.Resources.Trace_TuneStart, location, group), BDASettings.BDATraceSwitch.DisplayName); } // Route request through the current pipeline using (var tune = TuneToken.Create(TunePipeline, location, group)) tune.Execute(); // Not yet up if (analyser == null) { return; } // Attach to statistics interface var statistics = TunerFilter.GetSignalStatistics(); if (statistics != null) { try { // Set counter var tuneRetry = 10; // Wait for (; tuneRetry-- > 0; Thread.Sleep(100)) { // Load the signal information var locked = statistics.SignalLocked; if (locked != 0) { break; } } // Report if (BDASettings.BDATraceSwitch.Enabled) { Trace.WriteLine(string.Format(Properties.Resources.Trace_Lock, 10 - tuneRetry, tuneRetry, BDASettings.FastTune), BDASettings.BDATraceSwitch.DisplayName); } // Final check if (BDASettings.FastTune) { if (statistics.SignalLocked == 0) { return; } } } catch { // Just ignore any error } finally { // Back to COM BDAEnvironment.Release(ref statistics); } } // Check for dump StartDump(); // Reset PAT detection parser.RestartPATCounter(); // Request the number of bytes currently processed var bytes = parser.BytesReceived; var limit = patsExpected; var retry = patRetries; // Wait a bit for (; (parser.ValidPATCount < limit) && (retry-- > 0);) { Thread.Sleep(100); } // Report if (BDASettings.BDATraceSwitch.Enabled) { Trace.WriteLine(string.Format(Properties.Resources.Trace_StreamOk, patRetries - retry, retry, parser.ValidPATCount, parser.BytesReceived - bytes), BDASettings.BDATraceSwitch.DisplayName); } // Disable retry if PATs are received if (parser.ValidPATCount >= limit) { break; } // Disable retry if no data is on the transponder if (bytes == parser.BytesReceived) { if (outerRetry != 3) { break; } } // Report for debugging purposes if (BDASettings.BDATraceSwitch.Enabled) { Trace.WriteLine(Properties.Resources.Trace_TuneFailed, BDASettings.BDATraceSwitch.DisplayName); } // Inform all helpers on reset SendEmptyTuneRequest(DisableCIResetOnTuneFailure); } }
/// <summary> /// Beendet die Nutzung dieser Instanz endgültig. /// </summary> public void Dispose() => BDAEnvironment.Release(ref m_Request);
/// <summary> /// Beendet die Nutzung dieser Instanz endgültig. /// </summary> public void Dispose() { // Cleanup BDAEnvironment.Release(ref m_Object); }
/// <summary> /// Beendet die Nutzung dieser Instanz endgültig. /// </summary> public override void Dispose() { // Check interface BDAEnvironment.Release(ref m_Interface); }