C# IDisposable.Dispose方法代码示例

        public bool Add(IDisposable d)
        {
            if (disposed)
            {
                d.Dispose();
                return false;
            }

            lock (this)
            {
                if (!disposed)
                {
                    var set = this.set;
                    if (set == null)
                    {
                        set = new LinkedList<IDisposable>();
                        this.set = set;
                    }

                    set.AddLast(d);

                    return true;
                }
            }

            d.Dispose();
            return false;
        }

        static void ListenWithQuery()
        {
            Console.WriteLine("----- Listening with Tx-Playback and Rx query -----");
            _playback = new Playback();
            _playback.AddRealTimeSession(Baseline.SessionName);

            var received = _playback.GetObservable<KNetEvt_RecvIPV4>();

            var x = from window in received.Window(TimeSpan.FromSeconds(1), _playback.Scheduler)
                    from stats in
                        (from packet in window
                         group packet by packet.daddr into g
                         from total in g.Sum(p => p.size)
                         select new
                         {
                             address = new IPAddress(g.Key).ToString(),
                             received = total
                         })
                            .ToList()
                    select stats.OrderBy(s => s.address);

            _subscription = x.Subscribe(v =>
            {
                Console.WriteLine("--- {0} ---", DateTime.Now);
                foreach (var s in v)
                    Console.WriteLine("{0, -15} {1,-10:n0} ", s.address, s.received);
                Console.WriteLine();
            });

            _playback.Start();
            Console.ReadLine();
            _subscription.Dispose();
        }

 public static void Dispose(IDisposable disposable)
 {
     if (disposable != null)
     {
         disposable.Dispose();
     }
 }

			private static void Close(IDisposable counter)
			{
				if (null != counter)
				{
					counter.Dispose();
				}
			}

 // ::
 public static void p_StreamDispose(IDisposable ido)
 {
     if (ido != null)
     {
         ido.Dispose();
     }
 }

        public void Set(IDisposable disposable)
        {
            if (disposable == null)
            {
                throw new ArgumentNullException("disposable");
            }

            object originalFieldValue = Interlocked.CompareExchange(ref _disposable, disposable, null);
            if (originalFieldValue == null)
            {
                // this is the first call to Set() and Dispose() hasn't yet been called; do nothing
            }
            else if (originalFieldValue == _disposedSentinel)
            {
                // Dispose() has already been called, so we need to dispose of the object that was just added
                disposable.Dispose();
            }
            else
            {
#if !NET35 && !SILVERLIGHT && !NETFX_CORE
                // Set has been called multiple times, fail
                Debug.Fail("Multiple calls to Disposer.Set(IDisposable) without calling Disposer.Dispose()");
#endif
            }
        }

 static void DisposeIt(IDisposable d)
 {
     if (d != null)
       {
     d.Dispose ();
       }
 }

        public static IDisposable Combine(IDisposable first, IDisposable second)
        {
            if (first == null || second == null)
                return first ?? second;

            return new Disposable(() => { try { first.Dispose(); } finally { second.Dispose(); } });
        }

 /// <summary>
 /// 释放对象
 /// </summary>
 /// <param name="disposeObject"></param>
 protected void DisposeIt(IDisposable disposeObject)
 {
     if (disposeObject != null)
     {
         disposeObject.Dispose();
     }
 }

        private static void DisposePage(IDisposable page)
        {
            if (page == null)
                return;

            page.Dispose();
        }

		public bool BeginTransaction ()
		{
			if (inTransaction)
				throw new InvalidOperationException ("Already in a transaction");
			
			transactionLock = LockWrite ();
			try {
				updatingLock = new FileStream (UpdateDatabaseLockFile, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
			} catch (IOException) {
				// The database is already being updated. Can't do anything for now.
				return false;
			} finally {
				transactionLock.Dispose ();
			}

			// Delete .new files that could have been left by an aborted database update
			
			transactionLock = LockRead ();
			CleanDirectory (rootDirectory);
			
			inTransaction = true;
			foldersToUpdate = new Hashtable ();
			deletedFiles = new Hashtable ();
			deletedDirs = new Hashtable ();
			return true;
		}

        private static void Run()
        {
            if (Arguments.NumClients > 1)
            {
                AppHost = WebApp.Start<Startup>(Arguments.ControllerUrl);

                if (!WaitForClientsToConnect())
                {
                    SignalPhaseChange(ControllerEvents.Abort);
                    for (int attempts = 0; (ClientsConnected > 0) && (attempts < CrankArguments.ConnectionPollAttempts); attempts++)
                    {
                        Thread.Sleep(CrankArguments.ConnectionPollIntervalMS);
                    }

                    AppHost.Dispose();
                    return;
                }
            }

            RunConnect();
            RunSend();
            RunDisconnect();

            WaitForLastSamples();

            if (AppHost != null)
            {
                AppHost.Dispose();
            }

            FlushLog(force:true);
        }

        public async void ExpectPolicy()
        {
            var address = GetRandomAddress();
            _server = WebApp.Start(address, appBuilder =>
            {
                
                appBuilder.Use<CrossDomainMiddleware>(new CrossDomainOptions()
                {
                    CaseSensitive = true
                });

                appBuilder.UseWebApi(_config);

            });

            _client = new HttpClient();
            var request = new HttpRequestMessage(HttpMethod.Get, address + "/crossdomain.xml");

            var httpResponseMessage = await _client.SendAsync(request);
            HttpContent httpContent = httpResponseMessage.Content;
            IEnumerable<string> values;
            httpContent.Headers.TryGetValues("Content-Type", out values);
            var assert = values as string[] ?? values.ToArray();
            assert.Should().NotBeNull(Policy);
            assert.Should().NotBeNull("text/x-cross-domain-policy");
               
            _server.Dispose();
        }

 private void Dispose(IDisposable disposable)
 {
     if (disposable != null)
     {
         disposable.Dispose();
     }
 }

        public static void RemoveAndDispose(this MultipleDisposable self, IDisposable target)
        {
            if (target == null)
                return;

            self.Remove(target);
            target.Dispose();
        }