How can I make a copy of a CookieContainer?

Question

Given, instances of CookieContainer are not thread safe.

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

So it turns out I cannot use the same container across multiple concurrent HTTP requests without synchronization. Unfortunatelly from the documentation at MSDN it's not clear how one can properly synchronize it.

A solution would be using a copy of a master container for each request and once the request is finished the cookies from the copy could be merged back to the master container. Creating a copy and merging can be done in a synchronized manner.

So the question is : how can I make a copy of an instance of the CookieContainer class?

Answer 1

The CookieContainer class is Serializable. Since you said you need to serialize it anyway, why not just use a BinaryFormatter to serialize it to a MemorySteam and then Deserialize it to make a copy?

I know this is overly simple, so please ignore if it isn't helpful.

private CookieContainer CopyContainer(CookieContainer container)
{
    using(MemoryStream stream = new MemoryStream())
    {
        BinaryFormatter formatter = new BinaryFormatter();
        formatter.Serialize(stream, container);
        stream.Seek(0, SeekOrigin.Begin);
        return (CookieContainer)formatter.Deserialize(stream);
    }
}

Answer 2

Take a look at the CookieContainter class and you'll see that concurrent scenarios are suppose to occur when there are changes in the cookie collection, right?

You'll notice that the author of CookieContainer took care of using lock {} and SyncRoot all around these collection-changing parts of the code, and I don't think that such approach is not addressed to concurrent scenarios.

Also, you can notice that any added Cookie is literally cloned, so the cookies inside the container and all the operations made will not mess up with object references outside the cookie container. In the worst case of I'm missing something, the clone also gives us a tip of what exactly you have to copy and how you could do it, in case of using the reflection approach described in the other posts (I personally would not consider it a hack, since it fits the requirement and it is managed, legal and safe code :) ).

In fact, the mentions all over MSDN documentation are "Any instance members are not guaranteed to be thread safe." - its a kind of reminder, because you are right, you really need to be careful. Then with such statement you can suppose basically two things: 1) Non-static members are not safe at all. 2) Some members can be thread safe, but they aren't properly documented.

Answer 3

You may use Reflection to get all cookies related to all Uris and then create new CookieContainer and add them to it, maybe such as here :

public static CookieContainer DeepClone(CookieContainer src)
{
    CookieContainer cookieContainer = new CookieContainer();

    Hashtable table = (Hashtable)src.GetType().InvokeMember("m_domainTable", BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance, null, src, new object[] { });

    foreach (var tableKey in table.Keys)
    {
        String str_tableKey = (string)tableKey;

        if (str_tableKey[0] == '.')
            str_tableKey = str_tableKey.Substring(1);

        SortedList list = (SortedList)table[tableKey].GetType().InvokeMember("m_list", BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance, null, table[tableKey], new object[] { });

        foreach (var listKey in list.Keys)
        {
            String url = "https://" + str_tableKey + (string)listKey;

            CookieCollection collection = src.GetCookies(new Uri(url));

            foreach (Cookie c in collection)
                cookieContainer.Add(new Cookie(c.Name, c.Value, c.Path, c.Domain)
                {
                    Comment = c.Comment,
                    CommentUri = c.CommentUri,
                    Discard = c.Discard,
                    Expired = c.Expired,
                    Expires = c.Expires,
                    HttpOnly = c.HttpOnly,
                    Port = c.Port,
                    Secure = c.Secure,
                    Version = c.Version
                });
        }
    }
    return cookieContainer;
}

Answer 4

You can do it with reflection. This may be able to be improved and YMMV:

//Set up the source cookie container
var cookieContainerA = new CookieContainer();
cookieContainerA.Add(new Uri("http://foobar.com"), new Cookie("foo", "bar"));
cookieContainerA.Add(new Uri("http://foobar.com"), new Cookie("baz", "qux"));
cookieContainerA.Add(new Uri("http://abc123.com"), new Cookie("abc", "123"));
cookieContainerA.Add(new Uri("http://abc123.com"), new Cookie("def", "456"));

//Set up our destination cookie container
var cookieContainerB = new CookieContainer();

//Get the domain table member
var type = typeof(CookieContainer);
var domainTableField = type.GetField("m_domainTable", BindingFlags.NonPublic | BindingFlags.Instance);
var domainTable = (Hashtable)domainTableField.GetValue(cookieContainerA);

//Iterate the domain table
foreach (var obj in domainTable)
{
  var entry = (DictionaryEntry)obj;

  //The domain is the key (we only need this for our Console.WriteLine later)
  var domain = entry.Key;
  var valuesProperty = entry.Value.GetType().GetProperty("Values");
  var values = (IList)valuesProperty.GetValue(entry.Value);

  foreach (var valueObj in values)
  {
    //valueObj is a CookieCollection, cast and add to our destination container
    var cookieCollection = (CookieCollection)valueObj;
    cookieContainerB.Add(cookieCollection);

    //This is a dump of our source cookie container
    foreach (var cookieObj in cookieCollection)
    {
      var cookie = (Cookie)cookieObj;
      Console.WriteLine("Domain={0}, Name={1}, Value={2}", domain, cookie.Name, cookie.Value);
    }
  }
}


//Test the copying
//var foobarCookies = cookieContainerB.GetCookies(new Uri("http://foobar.com"));
//var abc123Cookies = cookieContainerB.GetCookies(new Uri("http://abc123.com"));

Answer 5

Just adding my own twist on Alan's answer above to convert to/from a Base64 string.

public static string ToBase64(CookieContainer container)
{
    string str = null;

    byte[] bytes = null;
    using (MemoryStream ms = new MemoryStream())
    {
        BinaryFormatter bf = new BinaryFormatter();
        bf.Serialize(ms, container);
        bytes = ms.ToArray();
    }
    str = Convert.ToBase64String(bytes);

    return str;
}

public static CookieContainer FromBase64(string container_base64)
{
    CookieContainer cc = null;

    byte[] bytes = Convert.FromBase64String(container_base64);
    using (MemoryStream ms = new MemoryStream(bytes))
    {
        BinaryFormatter bf = new BinaryFormatter();
        cc = (CookieContainer)bf.Deserialize(ms);
    }

    return cc;
}