public RangeConditionHeaderValue (EntityTagHeaderValue entityTag)
		{
			if (entityTag == null)
				throw new ArgumentNullException ("entityTag");

			EntityTag = entityTag;
		}

        private EntityTagHeaderValue(EntityTagHeaderValue source)
        {
            Contract.Requires(source != null);

            _tag = source._tag;
            _isWeak = source._isWeak;
        }

        private EntityTagHeaderValue(EntityTagHeaderValue source)
        {
            Contract.Requires(source != null);

            this.tag = source.tag;
            this.isWeak = source.isWeak;
        }

        /// <summary>
        /// The on action executed.
        /// </summary>
        /// <param name="context">
        /// The context.
        /// </param>
        public override void OnActionExecuted(HttpActionExecutedContext context)
        {
            var request = context.Request;
            var key = GetKey(request);

            EntityTagHeaderValue etag = null;

            bool isGet = request.Method == HttpMethod.Get;
            bool isPutOrPost = request.Method == HttpMethod.Put || request.Method == HttpMethod.Post;

            if (isPutOrPost)
            {
                ////empty the dictionary because the resource has been changed.So now all tags will be cleared and data
                //// will be fetched from server. It would be good to implement a logic in which only change the ETags
                //// of that urls which are affected by this post or put method rather than clearing entire dictionary
                     etags.Clear();
                //// generate new ETag for Put or Post because the resource is changed.
                    etag = new EntityTagHeaderValue("\"" + Guid.NewGuid().ToString() + "\"");
                    etags.AddOrUpdate(key, etag, (k, val) => etag);

            }
            //if ((isGet && !etags.TryGetValue(key, out etag)) || isPutOrPost)
            //{
            //    //// generate new ETag for Put or Post because the resource is changed.
            //    etag = new EntityTagHeaderValue("\"" + Guid.NewGuid().ToString() + "\"");
            //    etags.AddOrUpdate(key, etag, (k, val) => etag);
            //}

            if (isGet)
            {
                context.Response.Headers.ETag = etag;
            }
        }

	    protected HttpResponseMessage GetInternal(string path)
	    {
	        var pathInfo = PathInfo.Create(path);

	        var filePath = _fileSystem.Path.Combine(this.FilePath, pathInfo);
            if (!_fileSystem.FileExists(filePath))
                return new HttpResponseMessage(HttpStatusCode.NotFound);

	        var eTag = new EntityTagHeaderValue(string.Concat("\"", _fileSystem.GetFileInfo(filePath).Etag, "\""));
	        if (Request.Headers.IfNoneMatch != null)
	        {
	            foreach (var noneMatch in Request.Headers.IfNoneMatch)
	            {
	                if (eTag.Equals(noneMatch))
	                    return new HttpResponseMessage(HttpStatusCode.NotModified);
	            }
	        }

            var stream = _fileSystem.OpenRead(filePath);
            var message = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StreamContent(stream) };
            message.Content.Headers.ContentType = new MediaTypeHeaderValue(GetMimeType(_fileSystem.Path.GetExtension(pathInfo).ToLower()));
	        message.Headers.ETag = eTag;

			// remove Pragma
		    message.Headers.Remove("Pragma");

		    message.Headers.CacheControl = new CacheControlHeaderValue {Private = true, MaxAge = TimeSpan.Zero};
			message.Content.Headers.Expires = DateTimeOffset.Now.Subtract(TimeSpan.FromSeconds(1));
		    //message.Content.Headers.LastModified

			return message;
	    }

        public IDictionary<string, object> ParseETag(EntityTagHeaderValue etagHeaderValue)
        {
            if (etagHeaderValue == null)
            {
                throw Error.ArgumentNull("etagHeaderValue");
            }

            string tag = etagHeaderValue.Tag.Trim('\"');

            // split etag
            string[] rawValues = tag.Split(Separator);
            IDictionary<string, object> properties = new Dictionary<string, object>();
            for (int index = 0; index < rawValues.Length; index++)
            {
                string rawValue = rawValues[index];

                // base64 decode
                byte[] bytes = Convert.FromBase64String(rawValue);
                string valueString = Encoding.UTF8.GetString(bytes);
                object obj = ODataUriUtils.ConvertFromUriLiteral(valueString, ODataVersion.V3);
                if (obj is ODataUriNullValue)
                {
                    obj = null;
                }
                properties.Add(index.ToString(CultureInfo.InvariantCulture), obj);
            }

            return properties;
        }

        private EntityTagHeaderValue(EntityTagHeaderValue source)
        {
            Debug.Assert(source != null);

            _tag = source._tag;
            _isWeak = source._isWeak;
        }

 public void Equals()
 {
     var tfhv = new EntityTagHeaderValue ("\"abc\"");
     Assert.AreEqual (tfhv, new EntityTagHeaderValue ("\"abc\""), "#1");
     Assert.AreNotEqual (tfhv, new EntityTagHeaderValue ("\"AbC\""), "#2");
     Assert.AreNotEqual (tfhv, new EntityTagHeaderValue ("\"AA\""), "#3");
 }

        public NotModifiedResponse(HttpRequestMessage request, EntityTagHeaderValue etag)
            : base(HttpStatusCode.NotModified)
        {
            if(etag!=null)
                this.Headers.ETag = etag;

            this.RequestMessage = request;
        }

        public RangeConditionHeaderValue(EntityTagHeaderValue entityTag)
        {
            if (entityTag == null)
            {
                throw new ArgumentNullException(nameof(entityTag));
            }

            _entityTag = entityTag;
        }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            if (request.Method == HttpMethod.Get)
            {
                // should we ignore trailing slash
                var resource = request.RequestUri.ToString();

                ICollection<EntityTagHeaderValue> etags = request.Headers.IfNoneMatch;
                // compare the Etag with the one in the cache
                // do conditional get.
                EntityTagHeaderValue actualEtag = null;
                if (etags.Count > 0 && ETagHandler.ETagCache.TryGetValue(resource, out actualEtag))
                {
                    if (etags.Any(etag => etag.Tag == actualEtag.Tag))
                    {
                        return Task.Factory.StartNew<HttpResponseMessage>(task => new NotModifiedResponse(), cancellationToken);
                    }
                }
            }
            else if (request.Method == HttpMethod.Put)
            {
                // should we ignore trailing slash
                var resource = request.RequestUri.ToString();

                ICollection<EntityTagHeaderValue> etags = request.Headers.IfMatch;
                // compare the Etag with the one in the cache
                // do conditional get.

                EntityTagHeaderValue actualEtag = null;
                if (etags.Count > 0 && ETagHandler.ETagCache.TryGetValue(resource, out actualEtag))
                {
                    var matchFound = etags.Any(etag => etag.Tag == actualEtag.Tag);

                    if (!matchFound)
                    {
                        return Task.Factory.StartNew<HttpResponseMessage>(task => new ConflictResponse(), cancellationToken);
                    }
                }
            }
            return base.SendAsync(request, cancellationToken).ContinueWith(task =>
            {
                var httpResponse = task.Result;
                var eTagKey = request.RequestUri.ToString();
                EntityTagHeaderValue eTagValue;

                // Post would invalidate the collection, put should invalidate the individual item
                if (!ETagCache.TryGetValue(eTagKey, out eTagValue) || request.Method == HttpMethod.Put || request.Method == HttpMethod.Post)
                {
                    eTagValue = new EntityTagHeaderValue("\"" + Guid.NewGuid().ToString() + "\"");
                    ETagCache.AddOrUpdate(eTagKey, eTagValue, (key, existingVal) => eTagValue);
                }
                httpResponse.Headers.ETag = eTagValue;

                return httpResponse;
            });
        }

        public static void SetEntityTagHeader(this HttpResponseMessage httpResponseMessage, EntityTagHeaderValue etag, DateTime lastModified)
        {
            if (httpResponseMessage.Content == null)
            {
                httpResponseMessage.Content = new NullContent();
            }

            httpResponseMessage.Headers.ETag = etag;
            httpResponseMessage.Content.Headers.LastModified = lastModified;
        }

        public void ToString_UseDifferentETags_AllSerializedCorrectly()
        {
            EntityTagHeaderValue etag = new EntityTagHeaderValue("\"e tag\"");
            Assert.Equal("\"e tag\"", etag.ToString());

            etag = new EntityTagHeaderValue("\"e tag\"", true);
            Assert.Equal("W/\"e tag\"", etag.ToString());

            etag = new EntityTagHeaderValue("\"\"", false);
            Assert.Equal("\"\"", etag.ToString());
        }

        public void Should_return_Conflict_for_Put_if_key_is_in_header_but_match_not_found_in_cache()
        {
            var eTagHandler = GetHandler();

            var requestMessage = new HttpRequestMessage(HttpMethod.Put, etag.Key);
            requestMessage.Headers.Add("If-Match", etag.Value.Tag);

            var newRandomValue = new EntityTagHeaderValue("\"" + Guid.NewGuid() + "\"");
            AddETagValue(new KeyValuePair<string, EntityTagHeaderValue>(etag.Key, newRandomValue));

            var response = ExecuteRequest(eTagHandler, requestMessage);

            response.StatusCode.ShouldEqual(HttpStatusCode.Conflict);
        }

        public void GetHashCode_UseSameAndDifferentETags_SameOrDifferentHashCodes()
        {
            EntityTagHeaderValue etag1 = new EntityTagHeaderValue("\"tag\"");
            EntityTagHeaderValue etag2 = new EntityTagHeaderValue("\"TAG\"");
            EntityTagHeaderValue etag3 = new EntityTagHeaderValue("\"tag\"", true);
            EntityTagHeaderValue etag4 = new EntityTagHeaderValue("\"tag1\"");
            EntityTagHeaderValue etag5 = new EntityTagHeaderValue("\"tag\"");
            EntityTagHeaderValue etag6 = EntityTagHeaderValue.Any;

            Assert.NotEqual(etag1.GetHashCode(), etag2.GetHashCode());
            Assert.NotEqual(etag1.GetHashCode(), etag3.GetHashCode());
            Assert.NotEqual(etag1.GetHashCode(), etag4.GetHashCode());
            Assert.NotEqual(etag1.GetHashCode(), etag6.GetHashCode());
            Assert.Equal(etag1.GetHashCode(), etag5.GetHashCode());
        }

        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            var request = actionExecutedContext.Request;
              var key = GetKey(request);

              EntityTagHeaderValue entityTag;

              if (!_etTagHeaderValues.TryGetValue(key, out entityTag) || request.Method == HttpMethod.Post || request.Method == HttpMethod.Post) {
            entityTag = new EntityTagHeaderValue("\"" + Guid.NewGuid().ToString() + "\"");
            _etTagHeaderValues.AddOrUpdate(key, entityTag, (k, val) => entityTag);
              }

              actionExecutedContext.Response.Headers.ETag = entityTag;
              SetCacheControl(actionExecutedContext.Response);
        }

        /// <summary>
        /// Checks if the request is conditional having a <c>If-None-Match</c> HTTP header field with a value that matches the 
        /// <paramref name="current"/> value. In the case of <c>true</c> this can be used to indicate that a 
        /// 304 (Not Modified) or a 412 (Precondition Failed) status code should be used.
        /// </summary>
        /// <param name="request">The request to match.</param>
        /// <param name="current">The current etag for the resource. If there is no current etag (i.e. the resource does not yet 
        /// exist) then use <c>null</c>.</param>
        /// <returns>Returns <c>true</c> if one of the <c>If-None-Match</c> values match the current etag; or the 
        /// <c>If-None-Match</c> value is "*" and <paramref name="current"/> is not null; otherwise false.</returns>
        public static bool IsIfNoneMatch(this HttpRequestMessage request, EntityTagHeaderValue current)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            if (request.Headers.IfNoneMatch != null)
            {
                foreach (EntityTagHeaderValue etag in request.Headers.IfNoneMatch)
                {
                    if (current != null && (etag == EntityTagHeaderValue.Any || current.Equals(etag)))
                    {
                        return true;
                    }
                }
            }

            return false;
        }

        private void CheckValidParsedValue(string input, int startIndex, EntityTagHeaderValue expectedResult,
            int expectedIndex, bool supportsMultipleValues)
        {
            HttpHeaderParser parser = null;
            if (supportsMultipleValues)
            {
                parser = GenericHeaderParser.MultipleValueEntityTagParser;
            }
            else
            {
                parser = GenericHeaderParser.SingleValueEntityTagParser;
            }

            object result = null;
            Assert.True(parser.TryParseValue(input, null, ref startIndex, out result),
                string.Format("TryParse returned false. Input: '{0}', AllowMultipleValues/Any: {1}", input,
                supportsMultipleValues));
            Assert.Equal(expectedIndex, startIndex);
            Assert.Equal(result, expectedResult);
        }

        public object GetModule(string name)
        {
            var module = ViewModuleProvider.ResolveViewModule(name);
            if (module == null)
                return NotFound();

            var eTagHeaderValue = new EntityTagHeaderValue("\"" + module.ETag + "\"");
            if (Request.Headers.IfNoneMatch.Contains(eTagHeaderValue))
                return new HttpResponseMessage(HttpStatusCode.NotModified);

            var lastModifiedTime = (DateTimeOffset?)module.LastModifiedTime;
            if (Request.Headers.IfModifiedSince >= lastModifiedTime)
                return new HttpResponseMessage(HttpStatusCode.NotModified);

            var response = new HttpResponseMessage(HttpStatusCode.OK);
            response.Headers.ETag = eTagHeaderValue;
            response.Headers.CacheControl = new CacheControlHeaderValue() { Public = true };
            response.Content = new PushStreamContent((s, c, t) => { module.Write(s); s.Close(); });
            response.Content.Headers.ContentType = new MediaTypeHeaderValue(module.ContentType);
            response.Content.Headers.LastModified = lastModifiedTime;
            return response;
        }

	    protected HttpResponseMessage GetInternal(string path)
	    {
	        var pathInfo = PathInfo.Create(path);

	        var filePath = _fileSystem.Path.Combine(this.FilePath, pathInfo);
            if (!_fileSystem.FileExists(filePath))
                return new HttpResponseMessage(HttpStatusCode.NotFound);

	        var eTag = new EntityTagHeaderValue(string.Concat("\"", _fileSystem.GetFileInfo(filePath).Etag, "\""));
	        if (Request.Headers.IfNoneMatch != null)
	        {
	            foreach (var noneMatch in Request.Headers.IfNoneMatch)
	            {
	                if (eTag.Equals(noneMatch))
	                    return new HttpResponseMessage(HttpStatusCode.NotModified);
	            }
	        }

            var stream = _fileSystem.OpenRead(filePath);
            var message = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StreamContent(stream) };
            message.Content.Headers.ContentType = new MediaTypeHeaderValue(GetMimeType(_fileSystem.Path.GetExtension(pathInfo).ToLower()));
	        message.Headers.ETag = eTag;
            return message;
	    }