I want to cache a data collection in asp.net mvc and filter this collection without to changed the cached collection.
Is it possible to do this?
Because for now, when I get my cached collection I get a reference to it and filter data of this collection change the cached collection.
Does anyone know?
Simply copy the items from your cached list to a new list. The instances will be the same but the original (cached) list will not be touched. Something like this:
List<[CLASS]> collectionCached; //assuming this this your cached list
List<[CLASS]> collectionWorking = new List<[CLASS]>();
collectionWorking.AddRange(collectionCached);
This will allow you to filter out any instances you want without touching the original (cached) list.
EDIT:
After further clarification from OP, it seems there is a need to make a copy of the entities themselves. The basic idea behind making a copy of a reference object is called "Cloning". This makes a copy of the original entity and allows you to change the copy without changing the original instance. SO has some good links, here is one that discusses both the concept of cloning and LINQ.
How to get a copy of data instead of a reference using linq/lambda in c#?
This should get you on the right track. Let me know if you have any other questions.
Cache the full list, and then use Linq to filter the collection.
var list = GetFromCache();
var filtered = list.Where(x => x.Name.Contains("rob"));
EDIT:
When you get this filtered list, are you changing the objects contained WITHIN the list? Yes, that would be reflected for the same instance in the cached list as well. But at that point it sounds like this isn't great data to be caching. Usually cached data doesn't change, or you can live without seeing changes for some time. If data accuracy is more important, don't cache.
You might be able to get what you want simply though, if you are changing the state of items in your lists:
var filtered = list.Where(x => x.Name.Contains("rob")).Select(x => x.MemberwiseClone()).Cast<YourObjType>();
This uses MemberwiseClone which does a shallow copy; if that's not good enough, you'll need do some work on a method that does a keep copy. It returns Object, so I use the Cast extension method to get it back to the type of object originally in the list.
What Malcolm Frexner is saying is a nice clean way to solve your problem but can be greatly simplified using AutoMapper.
Say you have an Adapter that you are pulling DTO objects from (or if you aren't using WCF if you are pulling it directly from the database, the same concept applies)
public class AccountServiceAdapter
{
private List<Accounts> _accounts
{
get
{
if(HttpContext.Current.Cache["accounts"] == null)
HttpContext.Current.Cache["accounts"] = default(List<Accounts>());
return (List<Accounts>)HttpContext.Current.Cache["accounts"];
}
set
{
HttpContext.Current.Cache["accounts"] = value;
}
}
public List<AccountViewModel> FetchAccounts()
{
if(_accounts == default(List<Accounts>))
{
//Do Fetch From Service or Persistence and set _accounts
}
return _accounts.Select(x => x.ConvertToViewModel()).ToList();
}
}
Well that's your caching piece which you likely already have written. The next bit is where you get to have a bit of fun. I won't explain all the mapping fun of AutoMapper because there's a billion links that do it but I'll give you some snippets to get you going.
https://github.com/AutoMapper/AutoMapper/wiki/Projection
You will need to make a ProjectionManager class after you have added a reference to AutoMapper using NuGet.
public static class ProjectionManager
{
ProjectionManager()
{
//The mapping exercise is AS SIMPLE as this if all you are doing is
//using the exact same property names, it'll autowire
//If you use different projections you can create complex maps see the link
//above.
Mapper.CreateMap<Account,AccountViewModel>();
Mapper.CreateMap<AccountViewModel,Account>();
}
//Make yourself some handy extension methods for syntactic sugar
public static AccountViewModel ConvertToViewModel(this Account x)
{
return Mapper.Map<Account,AccountViewModel>(x);
}
//Make yourself some handy extension methods for syntactic sugar
public static Account ConvertFromViewModel(this AccountViewModel x)
{
return Mapper.Map<AccountViewModel,Account>(x);
}
}
After you have done all of this your caching is now crazy simple and to boot you can cast your data into view models that have all the neat features like Validation, Display Names, etc without having to clutter up your Entity objects or your DTO object out of your WCF service!
This should work:
IEnumerable<T> things = GetThings();
Cache["ThingCache"] = things;
T aThing = ((IEnumerable)Cache["ThingCache"]).First();
//Cache["ThingCache"] should still contain the original collection.
I finally resolve my problem by creating a Clone() method in each of my objects and call Clone () method on my main object just after I retrieved it from cache.
My main object is of type account which contain himself list of domains, which contain list of product, etc...
Here is the Clone method in the Account object :
public Account Clone()
{
// Copy all properties of the object in a new object account
var account = (Account)this.MemberwiseClone();
var domainsList = new List<Domain>();
foreach (var d in this.Domains)
{
domainsList.Add(d.Clone());
}
account.Domains = domainsList;
return account;
}
Like you can see I use MemberwiseClone() to copy simple property and then I call Clone again on all complex objects. Clone which is a custom method I created in all of my complex objects.
And now it work fine...
I ran into this when I used my domain models directly in the View. As soon as you put all the displayed data in dedicated ViewModels, you easily work around the problem.
DomainModel
public class PersonInfo
{
public int Age {get;set;}
public string Name {get;set;}
}
ViewModel
public class PersonViewModel
{
public PersonInfo PersonData {get;set;}
public bool Visible {get;set;}
}
Now you can store PersonInfo in the cache without the risc of storing the property "Visible" for all users.
It gets a bit more difficult if you have lists of objects, but this pattern is applicable there to.
Far easiest is to serialize your objects to json before putting them into the cache and then deserialize when you get them out of there. That way you don't have to make any changes to your classes like implementing iclonable or similar.
Cache.Set(key, JsonConvert.SerializeObject(objectToCache), policy);
and then
var cachedObject = (string)Cache[ComposeKey(key, domain)];
return JsonConvert.DeserializeObject<T>(cachedObject);
This is my go-to code when dealing with cache poisoning:
var list_from_cache = HttpContext.Current.Cache["females"] as List<Females>;
var females = new List<Females>();
females.AddRange(list_from_cache.Select(n => Cloner(n))); //clone all objects
//now we can change the objects as much as we want without changing the cache
females[0].Height=160;
code for cloner, put this somewhere: (remember to put [Serializable] on your class-to-clone)
public static T Cloner<T>(T source) where T : class
{
if (!typeof(T).IsSerializable)
{
throw new ArgumentException("The type must be serializable.", "source");
}
// Don't serialize a null object, simply return the default for that object
if (Object.ReferenceEquals(source, null))
{
return default(T);
}
IFormatter formatter = new BinaryFormatter();
Stream stream = new MemoryStream();
using (stream)
{
formatter.Serialize(stream, source);
stream.Seek(0, SeekOrigin.Begin);
//return (T)formatter.Deserialize(stream);
var clone = formatter.Deserialize(stream) as T;
return clone;
}
}
This can be solved using System.Collections.Immutable.
You are looking for ImmutableList.
Get The nuget-package here: https://www.nuget.org/packages/System.Collections.Immutable/ or: Install-Package System.Collections.Immutable
