822 lines
20 KiB
C#
822 lines
20 KiB
C#
#region License
|
|
/*
|
|
* CookieCollection.cs
|
|
*
|
|
* This code is derived from CookieCollection.cs (System.Net) of Mono
|
|
* (http://www.mono-project.com).
|
|
*
|
|
* The MIT License
|
|
*
|
|
* Copyright (c) 2004,2009 Novell, Inc. (http://www.novell.com)
|
|
* Copyright (c) 2012-2019 sta.blockhead
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
#endregion
|
|
|
|
#region Authors
|
|
/*
|
|
* Authors:
|
|
* - Lawrence Pit <loz@cable.a2000.nl>
|
|
* - Gonzalo Paniagua Javier <gonzalo@ximian.com>
|
|
* - Sebastien Pouliot <sebastien@ximian.com>
|
|
*/
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
|
|
namespace WebSocketSharp.Net
|
|
{
|
|
/// <summary>
|
|
/// Provides a collection of instances of the <see cref="Cookie"/> class.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class CookieCollection : ICollection<Cookie>
|
|
{
|
|
#region Private Fields
|
|
|
|
private List<Cookie> _list;
|
|
private bool _readOnly;
|
|
private object _sync;
|
|
|
|
#endregion
|
|
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="CookieCollection"/> class.
|
|
/// </summary>
|
|
public CookieCollection ()
|
|
{
|
|
_list = new List<Cookie> ();
|
|
_sync = ((ICollection) _list).SyncRoot;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Internal Properties
|
|
|
|
internal IList<Cookie> List {
|
|
get {
|
|
return _list;
|
|
}
|
|
}
|
|
|
|
internal IEnumerable<Cookie> Sorted {
|
|
get {
|
|
var list = new List<Cookie> (_list);
|
|
if (list.Count > 1)
|
|
list.Sort (compareForSorted);
|
|
|
|
return list;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Properties
|
|
|
|
/// <summary>
|
|
/// Gets the number of cookies in the collection.
|
|
/// </summary>
|
|
/// <value>
|
|
/// An <see cref="int"/> that represents the number of cookies in
|
|
/// the collection.
|
|
/// </value>
|
|
public int Count {
|
|
get {
|
|
return _list.Count;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a value indicating whether the collection is read-only.
|
|
/// </summary>
|
|
/// <value>
|
|
/// <para>
|
|
/// <c>true</c> if the collection is read-only; otherwise, <c>false</c>.
|
|
/// </para>
|
|
/// <para>
|
|
/// The default value is <c>false</c>.
|
|
/// </para>
|
|
/// </value>
|
|
public bool IsReadOnly {
|
|
get {
|
|
return _readOnly;
|
|
}
|
|
|
|
internal set {
|
|
_readOnly = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a value indicating whether the access to the collection is
|
|
/// thread safe.
|
|
/// </summary>
|
|
/// <value>
|
|
/// <para>
|
|
/// <c>true</c> if the access to the collection is thread safe;
|
|
/// otherwise, <c>false</c>.
|
|
/// </para>
|
|
/// <para>
|
|
/// The default value is <c>false</c>.
|
|
/// </para>
|
|
/// </value>
|
|
public bool IsSynchronized {
|
|
get {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the cookie at the specified index from the collection.
|
|
/// </summary>
|
|
/// <value>
|
|
/// A <see cref="Cookie"/> at the specified index in the collection.
|
|
/// </value>
|
|
/// <param name="index">
|
|
/// An <see cref="int"/> that specifies the zero-based index of the cookie
|
|
/// to find.
|
|
/// </param>
|
|
/// <exception cref="ArgumentOutOfRangeException">
|
|
/// <paramref name="index"/> is out of allowable range for the collection.
|
|
/// </exception>
|
|
public Cookie this[int index] {
|
|
get {
|
|
if (index < 0 || index >= _list.Count)
|
|
throw new ArgumentOutOfRangeException ("index");
|
|
|
|
return _list[index];
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the cookie with the specified name from the collection.
|
|
/// </summary>
|
|
/// <value>
|
|
/// <para>
|
|
/// A <see cref="Cookie"/> with the specified name in the collection.
|
|
/// </para>
|
|
/// <para>
|
|
/// <see langword="null"/> if not found.
|
|
/// </para>
|
|
/// </value>
|
|
/// <param name="name">
|
|
/// A <see cref="string"/> that specifies the name of the cookie to find.
|
|
/// </param>
|
|
/// <exception cref="ArgumentNullException">
|
|
/// <paramref name="name"/> is <see langword="null"/>.
|
|
/// </exception>
|
|
public Cookie this[string name] {
|
|
get {
|
|
if (name == null)
|
|
throw new ArgumentNullException ("name");
|
|
|
|
var caseInsensitive = StringComparison.InvariantCultureIgnoreCase;
|
|
|
|
foreach (var cookie in Sorted) {
|
|
if (cookie.Name.Equals (name, caseInsensitive))
|
|
return cookie;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an object used to synchronize access to the collection.
|
|
/// </summary>
|
|
/// <value>
|
|
/// An <see cref="object"/> used to synchronize access to the collection.
|
|
/// </value>
|
|
public object SyncRoot {
|
|
get {
|
|
return _sync;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
|
|
private void add (Cookie cookie)
|
|
{
|
|
var idx = search (cookie);
|
|
if (idx == -1) {
|
|
_list.Add (cookie);
|
|
return;
|
|
}
|
|
|
|
_list[idx] = cookie;
|
|
}
|
|
|
|
private static int compareForSort (Cookie x, Cookie y)
|
|
{
|
|
return (x.Name.Length + x.Value.Length)
|
|
- (y.Name.Length + y.Value.Length);
|
|
}
|
|
|
|
private static int compareForSorted (Cookie x, Cookie y)
|
|
{
|
|
var ret = x.Version - y.Version;
|
|
return ret != 0
|
|
? ret
|
|
: (ret = x.Name.CompareTo (y.Name)) != 0
|
|
? ret
|
|
: y.Path.Length - x.Path.Length;
|
|
}
|
|
|
|
private static CookieCollection parseRequest (string value)
|
|
{
|
|
var ret = new CookieCollection ();
|
|
|
|
Cookie cookie = null;
|
|
var ver = 0;
|
|
|
|
var caseInsensitive = StringComparison.InvariantCultureIgnoreCase;
|
|
var pairs = value.SplitHeaderValue (',', ';').ToList ();
|
|
|
|
for (var i = 0; i < pairs.Count; i++) {
|
|
var pair = pairs[i].Trim ();
|
|
if (pair.Length == 0)
|
|
continue;
|
|
|
|
var idx = pair.IndexOf ('=');
|
|
if (idx == -1) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (pair.Equals ("$port", caseInsensitive)) {
|
|
cookie.Port = "\"\"";
|
|
continue;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (idx == 0) {
|
|
if (cookie != null) {
|
|
ret.add (cookie);
|
|
cookie = null;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
var name = pair.Substring (0, idx).TrimEnd (' ');
|
|
var val = idx < pair.Length - 1
|
|
? pair.Substring (idx + 1).TrimStart (' ')
|
|
: String.Empty;
|
|
|
|
if (name.Equals ("$version", caseInsensitive)) {
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
int num;
|
|
if (!Int32.TryParse (val.Unquote (), out num))
|
|
continue;
|
|
|
|
ver = num;
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("$path", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
cookie.Path = val;
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("$domain", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
cookie.Domain = val;
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("$port", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
cookie.Port = val;
|
|
continue;
|
|
}
|
|
|
|
if (cookie != null)
|
|
ret.add (cookie);
|
|
|
|
if (!Cookie.TryCreate (name, val, out cookie))
|
|
continue;
|
|
|
|
if (ver != 0)
|
|
cookie.Version = ver;
|
|
}
|
|
|
|
if (cookie != null)
|
|
ret.add (cookie);
|
|
|
|
return ret;
|
|
}
|
|
|
|
private static CookieCollection parseResponse (string value)
|
|
{
|
|
var ret = new CookieCollection ();
|
|
|
|
Cookie cookie = null;
|
|
|
|
var caseInsensitive = StringComparison.InvariantCultureIgnoreCase;
|
|
var pairs = value.SplitHeaderValue (',', ';').ToList ();
|
|
|
|
for (var i = 0; i < pairs.Count; i++) {
|
|
var pair = pairs[i].Trim ();
|
|
if (pair.Length == 0)
|
|
continue;
|
|
|
|
var idx = pair.IndexOf ('=');
|
|
if (idx == -1) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (pair.Equals ("port", caseInsensitive)) {
|
|
cookie.Port = "\"\"";
|
|
continue;
|
|
}
|
|
|
|
if (pair.Equals ("discard", caseInsensitive)) {
|
|
cookie.Discard = true;
|
|
continue;
|
|
}
|
|
|
|
if (pair.Equals ("secure", caseInsensitive)) {
|
|
cookie.Secure = true;
|
|
continue;
|
|
}
|
|
|
|
if (pair.Equals ("httponly", caseInsensitive)) {
|
|
cookie.HttpOnly = true;
|
|
continue;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (idx == 0) {
|
|
if (cookie != null) {
|
|
ret.add (cookie);
|
|
cookie = null;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
var name = pair.Substring (0, idx).TrimEnd (' ');
|
|
var val = idx < pair.Length - 1
|
|
? pair.Substring (idx + 1).TrimStart (' ')
|
|
: String.Empty;
|
|
|
|
if (name.Equals ("version", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
int num;
|
|
if (!Int32.TryParse (val.Unquote (), out num))
|
|
continue;
|
|
|
|
cookie.Version = num;
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("expires", caseInsensitive)) {
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
if (i == pairs.Count - 1)
|
|
break;
|
|
|
|
i++;
|
|
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (cookie.Expires != DateTime.MinValue)
|
|
continue;
|
|
|
|
var buff = new StringBuilder (val, 32);
|
|
buff.AppendFormat (", {0}", pairs[i].Trim ());
|
|
|
|
DateTime expires;
|
|
if (
|
|
!DateTime.TryParseExact (
|
|
buff.ToString (),
|
|
new[] { "ddd, dd'-'MMM'-'yyyy HH':'mm':'ss 'GMT'", "r" },
|
|
CultureInfo.CreateSpecificCulture ("en-US"),
|
|
DateTimeStyles.AdjustToUniversal
|
|
| DateTimeStyles.AssumeUniversal,
|
|
out expires
|
|
)
|
|
)
|
|
continue;
|
|
|
|
cookie.Expires = expires.ToLocalTime ();
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("max-age", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
int num;
|
|
if (!Int32.TryParse (val.Unquote (), out num))
|
|
continue;
|
|
|
|
cookie.MaxAge = num;
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("path", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
cookie.Path = val;
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("domain", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
cookie.Domain = val;
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("port", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
cookie.Port = val;
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("comment", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
cookie.Comment = urlDecode (val, Encoding.UTF8);
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("commenturl", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
cookie.CommentUri = val.Unquote ().ToUri ();
|
|
continue;
|
|
}
|
|
|
|
if (name.Equals ("samesite", caseInsensitive)) {
|
|
if (cookie == null)
|
|
continue;
|
|
|
|
if (val.Length == 0)
|
|
continue;
|
|
|
|
cookie.SameSite = val.Unquote ();
|
|
continue;
|
|
}
|
|
|
|
if (cookie != null)
|
|
ret.add (cookie);
|
|
|
|
Cookie.TryCreate (name, val, out cookie);
|
|
}
|
|
|
|
if (cookie != null)
|
|
ret.add (cookie);
|
|
|
|
return ret;
|
|
}
|
|
|
|
private int search (Cookie cookie)
|
|
{
|
|
for (var i = _list.Count - 1; i >= 0; i--) {
|
|
if (_list[i].EqualsWithoutValue (cookie))
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private static string urlDecode (string s, Encoding encoding)
|
|
{
|
|
if (s.IndexOfAny (new[] { '%', '+' }) == -1)
|
|
return s;
|
|
|
|
try {
|
|
return HttpUtility.UrlDecode (s, encoding);
|
|
}
|
|
catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Internal Methods
|
|
|
|
internal static CookieCollection Parse (string value, bool response)
|
|
{
|
|
try {
|
|
return response
|
|
? parseResponse (value)
|
|
: parseRequest (value);
|
|
}
|
|
catch (Exception ex) {
|
|
throw new CookieException ("It could not be parsed.", ex);
|
|
}
|
|
}
|
|
|
|
internal void SetOrRemove (Cookie cookie)
|
|
{
|
|
var idx = search (cookie);
|
|
if (idx == -1) {
|
|
if (cookie.Expired)
|
|
return;
|
|
|
|
_list.Add (cookie);
|
|
return;
|
|
}
|
|
|
|
if (cookie.Expired) {
|
|
_list.RemoveAt (idx);
|
|
return;
|
|
}
|
|
|
|
_list[idx] = cookie;
|
|
}
|
|
|
|
internal void SetOrRemove (CookieCollection cookies)
|
|
{
|
|
foreach (var cookie in cookies._list)
|
|
SetOrRemove (cookie);
|
|
}
|
|
|
|
internal void Sort ()
|
|
{
|
|
if (_list.Count > 1)
|
|
_list.Sort (compareForSort);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Adds the specified cookie to the collection.
|
|
/// </summary>
|
|
/// <param name="cookie">
|
|
/// A <see cref="Cookie"/> to add.
|
|
/// </param>
|
|
/// <exception cref="InvalidOperationException">
|
|
/// The collection is read-only.
|
|
/// </exception>
|
|
/// <exception cref="ArgumentNullException">
|
|
/// <paramref name="cookie"/> is <see langword="null"/>.
|
|
/// </exception>
|
|
public void Add (Cookie cookie)
|
|
{
|
|
if (_readOnly) {
|
|
var msg = "The collection is read-only.";
|
|
throw new InvalidOperationException (msg);
|
|
}
|
|
|
|
if (cookie == null)
|
|
throw new ArgumentNullException ("cookie");
|
|
|
|
add (cookie);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the specified cookies to the collection.
|
|
/// </summary>
|
|
/// <param name="cookies">
|
|
/// A <see cref="CookieCollection"/> that contains the cookies to add.
|
|
/// </param>
|
|
/// <exception cref="InvalidOperationException">
|
|
/// The collection is read-only.
|
|
/// </exception>
|
|
/// <exception cref="ArgumentNullException">
|
|
/// <paramref name="cookies"/> is <see langword="null"/>.
|
|
/// </exception>
|
|
public void Add (CookieCollection cookies)
|
|
{
|
|
if (_readOnly) {
|
|
var msg = "The collection is read-only.";
|
|
throw new InvalidOperationException (msg);
|
|
}
|
|
|
|
if (cookies == null)
|
|
throw new ArgumentNullException ("cookies");
|
|
|
|
foreach (var cookie in cookies._list)
|
|
add (cookie);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes all cookies from the collection.
|
|
/// </summary>
|
|
/// <exception cref="InvalidOperationException">
|
|
/// The collection is read-only.
|
|
/// </exception>
|
|
public void Clear ()
|
|
{
|
|
if (_readOnly) {
|
|
var msg = "The collection is read-only.";
|
|
throw new InvalidOperationException (msg);
|
|
}
|
|
|
|
_list.Clear ();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Determines whether the collection contains the specified cookie.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// <c>true</c> if the cookie is found in the collection; otherwise,
|
|
/// <c>false</c>.
|
|
/// </returns>
|
|
/// <param name="cookie">
|
|
/// A <see cref="Cookie"/> to find.
|
|
/// </param>
|
|
/// <exception cref="ArgumentNullException">
|
|
/// <paramref name="cookie"/> is <see langword="null"/>.
|
|
/// </exception>
|
|
public bool Contains (Cookie cookie)
|
|
{
|
|
if (cookie == null)
|
|
throw new ArgumentNullException ("cookie");
|
|
|
|
return search (cookie) > -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the elements of the collection to the specified array,
|
|
/// starting at the specified index.
|
|
/// </summary>
|
|
/// <param name="array">
|
|
/// An array of <see cref="Cookie"/> that specifies the destination of
|
|
/// the elements copied from the collection.
|
|
/// </param>
|
|
/// <param name="index">
|
|
/// An <see cref="int"/> that specifies the zero-based index in
|
|
/// the array at which copying starts.
|
|
/// </param>
|
|
/// <exception cref="ArgumentNullException">
|
|
/// <paramref name="array"/> is <see langword="null"/>.
|
|
/// </exception>
|
|
/// <exception cref="ArgumentOutOfRangeException">
|
|
/// <paramref name="index"/> is less than zero.
|
|
/// </exception>
|
|
/// <exception cref="ArgumentException">
|
|
/// The space from <paramref name="index"/> to the end of
|
|
/// <paramref name="array"/> is not enough to copy to.
|
|
/// </exception>
|
|
public void CopyTo (Cookie[] array, int index)
|
|
{
|
|
if (array == null)
|
|
throw new ArgumentNullException ("array");
|
|
|
|
if (index < 0)
|
|
throw new ArgumentOutOfRangeException ("index", "Less than zero.");
|
|
|
|
if (array.Length - index < _list.Count) {
|
|
var msg = "The available space of the array is not enough to copy to.";
|
|
throw new ArgumentException (msg);
|
|
}
|
|
|
|
_list.CopyTo (array, index);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the enumerator that iterates through the collection.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// An <see cref="T:System.Collections.Generic.IEnumerator{Cookie}"/>
|
|
/// instance that can be used to iterate through the collection.
|
|
/// </returns>
|
|
public IEnumerator<Cookie> GetEnumerator ()
|
|
{
|
|
return _list.GetEnumerator ();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the specified cookie from the collection.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// <para>
|
|
/// <c>true</c> if the cookie is successfully removed; otherwise,
|
|
/// <c>false</c>.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>false</c> if the cookie is not found in the collection.
|
|
/// </para>
|
|
/// </returns>
|
|
/// <param name="cookie">
|
|
/// A <see cref="Cookie"/> to remove.
|
|
/// </param>
|
|
/// <exception cref="InvalidOperationException">
|
|
/// The collection is read-only.
|
|
/// </exception>
|
|
/// <exception cref="ArgumentNullException">
|
|
/// <paramref name="cookie"/> is <see langword="null"/>.
|
|
/// </exception>
|
|
public bool Remove (Cookie cookie)
|
|
{
|
|
if (_readOnly) {
|
|
var msg = "The collection is read-only.";
|
|
throw new InvalidOperationException (msg);
|
|
}
|
|
|
|
if (cookie == null)
|
|
throw new ArgumentNullException ("cookie");
|
|
|
|
var idx = search (cookie);
|
|
if (idx == -1)
|
|
return false;
|
|
|
|
_list.RemoveAt (idx);
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Explicit Interface Implementations
|
|
|
|
/// <summary>
|
|
/// Gets the enumerator that iterates through the collection.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// An <see cref="IEnumerator"/> instance that can be used to iterate
|
|
/// through the collection.
|
|
/// </returns>
|
|
IEnumerator IEnumerable.GetEnumerator ()
|
|
{
|
|
return _list.GetEnumerator ();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|