public void Initialize(IStateManager stateManager, IReferenceManager referenceManager, ISurrogateManager surrogateManager)
{
this.stateManager = stateManager;
this.referenceManager = referenceManager;
this.surrogateManager = surrogateManager;
var tkey = typeof(TKey);
var tvalue = typeof(TValue);
var tkeyIsValueTypeOrStringOrTypeNotStruct = IsValueTypeOrStringOrTypeNotStruct(tkey);
var tvalueIsValueTypeOrString = IsValueTypeOrStringOrType(tvalue);
if (tkeyIsValueTypeOrStringOrTypeNotStruct && tvalueIsValueTypeOrString)
{
implementation = new DictCase1 <TKey, TValue>();
CaseType = 1;
}
else if (tkeyIsValueTypeOrStringOrTypeNotStruct &&
(typeof(IStateObject).IsAssignableFrom(tvalue) ||
TypeCacheUtils.IsIListOrIDictionary(tvalue))
)
{
implementation = new DictCase2 <TKey, TValue>(stateManager, referenceManager);
((DictCase2 <TKey, TValue>)implementation).SetParent(this);
CaseType = 2;
}
else if (tkeyIsValueTypeOrStringOrTypeNotStruct && typeof(Delegate).IsAssignableFrom(tvalue))
{
implementation = new DictCase5 <TKey, TValue>(stateManager, surrogateManager);
CaseType = 5;
}
else if (typeof(IStateObject).IsAssignableFrom(tkey) && tvalueIsValueTypeOrString)
{
implementation = new DictCase3 <TKey, TValue>();
CaseType = 3;
}
else if (typeof(IStateObject).IsAssignableFrom(tkey) &&
(typeof(IStateObject).IsAssignableFrom(tvalue) || TypeCacheUtils.IsIListOrIDictionary(tvalue))
)
{
implementation = new DictCase4 <TKey, TValue>();
CaseType = 4;
}
else if (tkeyIsValueTypeOrStringOrTypeNotStruct && SurrogatesDirectory.IsSurrogateRegistered(tvalue))
{
implementation = new DictCase6 <TKey, TValue>(stateManager, surrogateManager, referenceManager);
((DictCase6 <TKey, TValue>)implementation).SetParent(this);
CaseType = 6;
}
else
{
throw new NotSupportedException();
}
}
public void InitializeTheList(IStateManager stateManager, IPageManager pageManager, IReferenceManager refManager, ISurrogateManager surManager, IUniqueIDGenerator uniqueIdGenerator, IServerEventAggregator serverEventAggregator)
{
_stateManager = stateManager;
_pageManager = pageManager;
_referenceManager = refManager;
_surrogateManager = surManager;
_uniqueIdGenerator = uniqueIdGenerator;
_serverEventAggregator = serverEventAggregator;
InitializeOperationHelper();
}
/// <summary>
/// This constructor is used for Mock Unit Testing purposes
/// </summary>
public VirtualList(IStateManager stateManager, IPageManager pageManager, IReferenceManager refManager, ISurrogateManager surManager = null, List <string> idxs = null, Dictionary <string, int> dict = null)
{
_stateManager = stateManager;
_pageManager = pageManager;
_referenceManager = refManager;
_surrogateManager = surManager;
PageUniqueIdOfTheIndexes = idxs ?? new List <string>();
InitialPositionOfEachPage = dict ?? new Dictionary <string, int>();
InitializeOperationHelper();
}
void IObservableDictionaryEntries.Initialize(IStateManager stateManager, IReferenceManager referenceManager, ISurrogateManager surrogateManager)
{
throw new NotImplementedException();
}
internal DictCase6(IStateManager stateManager, ISurrogateManager surrogateManager, IReferenceManager referencesManager)
{
_stateManager = stateManager;
this.surrogateManager = surrogateManager;
this.referencesManager = referencesManager;
}
/// <summary>
/// Get the dependencies associated to an object.
/// </summary>
/// <param name="obj">Object instance</param>
/// <param name="stateManager">StateManager instance</param>
/// <param name="surrogateManager">SurrogateManager instance</param>
/// <returns>List of dependencies</returns>
public static List <object> GetObjectDependencies(object obj, IStateManager stateManager, ISurrogateManager surrogateManager, ISurrogateDependencyManager surrogateDependencyManager)
{
var result = new List <object>();
lock (_syncSurrogates)
{
SurrogatesInfo info = null;
if (obj != null && TypeToSurrogate.TryGetValue(obj.GetType(), out info))
{
//If there any dependencies register for this type?
if (info.CalculateDependencies != null)
{
//Collects the object dependencies.
foreach (var dependency in info.CalculateDependencies)
{
var dependencies = dependency(obj, (ISurrogateDependenciesContext)surrogateDependencyManager);
if (dependencies != null)
{
result.AddRange(dependencies);
}
}
}
}
}
return(result);
}
internal DictCase5(IStateManager stateManager, ISurrogateManager surrogateManager)
{
this.stateManager = stateManager; this.surrogateManager = surrogateManager;
}
