public static void Main(String[] args)
{
int count = int.Parse(args[0]);
{
Console.Write("Good hash function: ");
Timer t = new Timer();
HashSet <int> good
= MakeRandom(count, new GoodIntegerEqualityComparer());
Console.WriteLine("({0} sec, {1} items)", t.Check(), good.Count);
ISortedDictionary <int, int> bcd = good.BucketCostDistribution();
foreach (KeyValuePair <int, int> entry in bcd)
{
Console.WriteLine("{0,7} bucket(s) with cost {1,5}",
entry.Value, entry.Key);
}
}
{
Console.Write("Bad hash function: ");
Timer t = new Timer();
HashSet <int> bad = MakeRandom(count, new BadIntegerEqualityComparer());
Console.WriteLine("({0} sec, {1} items)", t.Check(), bad.Count);
ISortedDictionary <int, int> bcd = bad.BucketCostDistribution();
foreach (KeyValuePair <int, int> entry in bcd)
{
Console.WriteLine("{0,7} bucket(s) with cost {1,5}",
entry.Value, entry.Key);
}
}
}
public EnumeratorEnumeratorFilter(ISortedDictionary <TKey, TValue> target,
IEnumerable <KeyValuePair <TSourceKey, TSourceValue> > source,
ExtractKey <TSourceKey, TSourceValue, TKey> sourceKeyExtractor = null,
bool lockWrap = false)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (source == null)
{
throw new ArgumentNullException("source");
}
if (lockWrap)
{
target.Locker.Lock(OperationType.Read);
}
_target = (ISortedDictionaryOnDisk)((SpecializedStoreBase)target).Collection.Clone();
_source = source.GetEnumerator();
_sourceKeyExtractor = sourceKeyExtractor;
_lockWrap = lockWrap;
if (_sourceKeyExtractor == null)
{
_sourceKeyExtractor = DefaultKeyExtractor <TSourceKey, TSourceValue, TKey>;
}
}
/// <summary>
/// Sample code to test general application usage of SOP.
/// This creates, populates and reads all records of 2 tables, People & Addresses.
/// This also showcases technique to take advantage of SOP feature of
/// "optimized" insertion/reading by doing said operations in batch per table.
///
/// NOTE: this is purely for demo purposes only. Ideal implementation will not
/// necessarily need two tables. Person and Address records may be merged
/// to one table for real world use.
/// </summary>
public void Run()
{
Console.WriteLine("{0}: BayWind demo started...", DateTime.Now);
//** Create a Store Factory
var storeFactory = new StoreFactory();
ISortedDictionary <PersonKey, Person> PeopleStore =
storeFactory.Get <PersonKey, Person>(Server.SystemFile.Store, "People", new PersonComparer());
ISortedDictionary <int, Address> AddressStore =
storeFactory.Get <int, Address>(Server.SystemFile.Store, "Address");
const int MaxCount = 3000;
if (PeopleStore.Count == 0)
{
Populate(PeopleStore, AddressStore, MaxCount);
Server.Commit();
}
else
{
Read(PeopleStore, AddressStore, MaxCount);
}
Console.WriteLine("{0}: BayWind demo ended...", DateTime.Now);
}
/// <summary>
/// Sample code that uses this VirtualCache.
/// </summary>
public static void Run()
{
Console.WriteLine("{0}: Virtual Cache demo started...", DateTime.Now);
VirtualCacheGenerics vc = new VirtualCacheGenerics();
ISortedDictionary <int, Person> cache1 = vc.GetObjectCache(1);
const int MaxCount = 40000;
for (int i = 0; i < MaxCount; i++)
{
Person p = new Person();
p.FirstName = string.Format("Joe{0}", i);
p.LastName = "Castanas";
p.PhoneNumber = "510-324-2222";
p.Address = string.Format("5434 {0} Coventry Court, Fremont, Ca. 94888, U.S.A.", i);
cache1.Add(i, p);
}
Console.WriteLine("{0}: Finished inserting {1} records, reading 'em starts now...", DateTime.Now, MaxCount);
cache1.MoveFirst();
cache1.HintSequentialRead = true;
for (int i = 0; i < MaxCount; i++)
{
Person p = cache1.CurrentValue;
if (p == null ||
p.FirstName != string.Format("Joe{0}", i))
{
Console.WriteLine("Error, data for iteration {0} not found.", i);
}
cache1.MoveNext();
}
Console.WriteLine("{0}: Virtual Cache demo ended... {1} records were read.", DateTime.Now, MaxCount);
}
/// <summary>
/// Sample code that tests creation and population of 400 tables with 5000 records each.
/// </summary>
public void Run()
{
Console.WriteLine("{0}: Collection400 demo started...", DateTime.Now);
const int CollCount = 40;
StoreFactory StoreFactory = new Sop.StoreFactory();
for (int i = 0; i < CollCount; i++)
{
string CollectionName = string.Format("People{0}", i);
ISortedDictionary <long, Person> store = StoreFactory.Get <long, Person>(Server.SystemFile.Store, CollectionName);
if (store.Count == 0)
{
Populate(store);
store.Transaction.Commit();
server.BeginTransaction();
}
}
for (int i = 0; i < CollCount; i++)
{
string CollectionName = string.Format("People{0}", i);
if (Server.SystemFile.Store.Contains(CollectionName))
{
ISortedDictionary <long, Person> store = StoreFactory.Get <long, Person>(Server.SystemFile.Store, CollectionName);
ReadAll(store);
}
}
Console.WriteLine("{0}: Collection400 demo ended...", DateTime.Now);
}
internal SortedKeysCollection(ISortedDictionary <K, V> sorteddict, ISorted <KeyValuePair <K, V> > sortedpairs, SCG.IComparer <K> comparer, SCG.IEqualityComparer <K> itemequalityComparer)
: base(itemequalityComparer)
{
this.sorteddict = sorteddict;
this.sortedpairs = sortedpairs;
this.comparer = comparer;
}
private void SetupSql()
{
_commandBuilder = new SqlCommandBuilder();
_db = new SqlConnection("Server=(localdb)\\ProjectsV12;Database=TestDictionary;Trusted_Connection=True");
_db.Open();
var formatter = new ProtobufValueFormatter();
_uut = new SqlSortedDictionary <string, string>(_tableName, _db, formatter, _commandBuilder, false);
}
void ReadAll(ref ISortedDictionary <string, object> Store)
{
int Ctr = 0;
string key = null;
const int batchCount = 1000;
string[] batch = new string[batchCount];
for (int i = 0; i < MaxCount; i++)
{
Ctr++;
switch (i % 4)
{
case 0:
key = string.Format("PersonBlob{0}", Ctr);
break;
case 1:
key = string.Format("Person{0}", Ctr);
break;
case 2:
key = string.Format("Address{0}", Ctr);
break;
case 3:
key = string.Format("Dept{0}", Ctr);
break;
}
batch[i % batchCount] = key;
if (i > 0 && i % batchCount == 0)
{
QueryResult <string>[] result;
if (!Store.Query(batch.Select((a) => new QueryExpression <string>()
{
Key = a
}).ToArray(), out result))
{
Console.WriteLine("Failed! 'can't find object {0}.", key);
}
else
{
foreach (var o in result)
{
if (!o.Found)
{
Console.WriteLine("Failed! 'can't find object {0}.", o.Key);
}
if (o.Value == null)
{
Console.WriteLine("Failed! 'found object {0} has null Value.", o.Key);
}
}
}
}
}
Console.WriteLine("Processed {0} records.", Ctr);
}
// "Bulk" read all Person and Address records from respective Stores...
private void Read(ISortedDictionary <PersonKey, Person> PeopleStore,
ISortedDictionary <int, Address> AddressStore, int MaxCount)
{
PeopleStore.MoveFirst();
// tell People Store it can do read ahead of 77 Persons.
PeopleStore.HintBatchCount = 77;
AddressStore.MoveFirst();
// tell Address Store it can do read ahead of 78 Addresses.
AddressStore.HintBatchCount = 78;
KeyValuePair <int, int>[] AddressIDs = new KeyValuePair <int, int> [AddressBatchCount];
int AddressBatchIndex = 0;
for (int i = 1; i <= MaxCount; i++)
{
Person p = PeopleStore.CurrentValue;
if (p.FirstName != string.Format("Joe{0}", i))
{
Console.WriteLine("Error detected, expected Joe{0} not found in this sequence from disk", i);
}
else
{
AddressIDs[AddressBatchIndex++] = new KeyValuePair <int, int>(p.AddressID, i);
if (AddressBatchIndex == AddressBatchCount)
{
int[] a2 = new int[AddressBatchCount];
for (int i2 = 0; i2 < AddressBatchCount; i2++)
{
a2[i2] = AddressIDs[i2].Key;
}
// Query a batch of 1000 addresses. NOTE: doing batch query is optimal operation
// as it minimizes segment jumps of the HDD "disk head".
QueryResult <int>[] Addresses;
if (AddressStore.Query(QueryExpression <int> .Package(a2), out Addresses))
{
for (int i2 = 0; i2 < AddressBatchCount; i2++)
{
Address addr = (Address)Addresses[i2].Value;
if (addr == null ||
addr.Street != string.Format("143{0} LoveLane", AddressIDs[i2].Value))
{
Console.WriteLine("Error detected, expected Address 143{0} not found in this sequence from disk",
AddressIDs[i2].Value);
}
}
}
AddressBatchIndex = 0;
}
}
PeopleStore.MoveNext();
}
if (!PeopleStore.EndOfTree())
{
Console.WriteLine("Expected EOT but isn't.");
}
Console.WriteLine("Reading all data({0}) ended.", MaxCount);
}
/// <summary>
/// Shows how to use two Object Servers with separate transaction for each.
/// </summary>
public static void Run()
{
string CacheFilename = "OFile.dta";
//** ObjectServer1 is to be physically stored in ...\Sop1 folder
string ServerPath1 = "SopBin\\Sop1\\";
//** ObjectServer2 is to be physically stored in ...\Sop2 folder
string ServerPath2 = "SopBin\\Sop2\\";
string ServerFilename = "OServer.dta";
//** create 1st ObjectServer & its transaction
ObjectServer server = Sop.ObjectServer.OpenWithTransaction(string.Format("{0}{1}", ServerPath1, ServerFilename),
new Preferences());
//** create 2nd ObjectServer & its transaction
string ServerFilename2 = "OServer2.dta";
string sfullpath2 = string.Format("{0}{1}", ServerPath2, ServerFilename2);
ObjectServer server2 = Sop.ObjectServer.OpenWithTransaction(sfullpath2);
string fn = string.Format("{0}{1}{2}", ServerPath1, 1, CacheFilename);
string fn2 = string.Format("{0}{1}{2}", ServerPath2, 2, CacheFilename);
Sop.IFile f = server.FileSet[CacheFilename];
if (f == null)
{
f = server.FileSet.Add(CacheFilename, fn);
}
IStoreFactory sf = new StoreFactory();
ISortedDictionary <int, Person>
store = sf.Get <int, Person>(f.Store, "VirtualCache");
Sop.IFile f2 = server2.FileSet[CacheFilename];
if (f2 == null)
{
f2 = server2.FileSet.Add(CacheFilename, fn2);
}
ISortedDictionary <int, Person>
store2 = sf.Get <int, Person>(f2.Store, "VirtualCache");
//** insert records
Console.WriteLine("Start Insertion then Validation of records & their sequence...");
object o = store.Transaction;
object o2 = store2.Transaction;
InsertRecords(store, 20003, "Store1");
ReadRecords(store, 20003, "Store1");
store.Transaction.Rollback();
InsertRecords(store2, 20501, "Store2");
ReadRecords(store2, 20501, "Store2");
store2.Transaction.Rollback();
Console.WriteLine("Done...");
}
void Populate(ISortedDictionary <string, object> Store)
{
for (int i = 0; i < MaxCount; i++)
{
int pid = (int)Store.GetNextSequence();
string key = string.Empty;
object value = null;
switch (i % 4)
{
case 0:
key = string.Format("PersonBlob{0}", pid);
value = new PersonBlob
{
Blob = new byte[PersonBlob.BlobAvgSize]
};
break;
case 1:
key = string.Format("Person{0}", pid);
value = new Person
{
FirstName = string.Format("Joe {0}", pid),
LastName = string.Format("Curly {0}", pid)
};
break;
case 2:
key = string.Format("Address{0}", pid);
value = new Address
{
Street = string.Format("123 Love Lane {0}", pid),
City = "Fremont",
State = "California",
Country = "U.S.A.",
ZipCode = 94599
};
break;
case 3:
key = string.Format("Dept{0}", pid);
value = new Department
{
Id = pid,
Name = string.Format("Dept {0}", pid)
};
break;
}
Store.Add(key, value);
if (i % 2000 == 0)
{
Store.Flush();
}
}
}
static long MeasureSuccessor <T>(uint[] itemSet, ISortedDictionary <uint, T> dict)
{
GC.Collect();
var timer = Stopwatch.StartNew();
for (int i = 0; i < itemSet.Length; i++)
{
dict.Higher(itemSet[i]);
}
timer.Stop();
return(timer.ElapsedMilliseconds);
}
/// <summary>
/// Sample code to show how to create nested Sorted Dictionaries.
/// I.e. - Collections within Collection scenario.
/// </summary>
public void Run()
{
Console.WriteLine("{0}: NestedSortedDictionary demo started...", DateTime.Now);
const int CollCount = 50;
ITransaction Trans;
IStoreFactory Factory = new StoreFactory();
//** Create/Get the Main Collection which we will store the nested "People" Sorted Dictionaries in below code...
ISortedDictionary <string, GeneralPurpose <long, Person> > Collections =
Factory.Get <string, GeneralPurpose <long, Person> >(Server.SystemFile.Store, "MainCollection");
for (int i = 0; i < CollCount; i++)
{
string CollectionName = string.Format("People{0}", i);
ISortedDictionary <long, Person> store = Factory.Get <long, Person>(Collections, CollectionName);
Trans = store.Transaction;
if (store.Count == 0)
{
Populate(store);
store.Flush();
//store.Dispose();
}
//else
// store.Dispose();
if (i >= 10)
{
//** get the table 5 tables "ago"
store = Factory.Get <long, Person>(Collections, string.Format("People{0}", i - 5));
//** delete the table retrieved...
//store.Clear();
store.Rename("foo");
ISortedDictionary <long, Person> fooStore = Factory.Get <long, Person>(Collections, "foo");
//store.Delete();
}
Trans.Commit();
server.BeginTransaction();
}
for (int i = 0; i < CollCount; i++)
{
string CollectionName = string.Format("People{0}", i);
ISortedDictionary <long, Person> store = Factory.Get <long, Person>(Collections, CollectionName, createIfNotExist: false);
if (store != null)
{
ReadAll(store);
//store.Dispose();
}
}
Console.WriteLine("{0}: NestedSortedDictionary demo ended...", DateTime.Now);
}
static void InsertRecords(ISortedDictionary <int, Person> store, int MaxCount, string Salt)
{
for (int i = 0; i < MaxCount; i++)
{
Person p = new Person();
p.FirstName = string.Format("Joe{0}{1}", i, Salt);
p.LastName = "Castanas";
p.PhoneNumber = "510-324-2222";
p.Address = string.Format("5434 {0} Coventry Court, Fremont, Ca. 94888, U.S.A.", i);
store.Add(i, p);
}
Console.WriteLine("InsertRecords ({0}) end.", MaxCount);
}
public EnumerableKeysFilter(ISortedDictionary <TKey, TValue> store, TKey[] keys, bool lockWrap = false)
{
if (keys == null)
{
throw new ArgumentNullException("keys");
}
if (store == null)
{
throw new ArgumentNullException("store");
}
_store = store;
_keys = keys;
_lockWrap = lockWrap;
}
void ReadAll(ObjectServer server,
ISortedDictionary <long, Person> PeopleStore,
int maxCount
)
{
for (int i = 0; i < maxCount; i++)
{
var v = PeopleStore.CurrentValue;
if (!PeopleStore.MoveNext())
{
break;
}
}
}
private void Populate(ISortedDictionary <PersonKey, Person> PeopleStore,
ISortedDictionary <int, Address> AddressStore, int MaxCount)
{
int[] AddressIDs = new int[AddressBatchCount];
int AddressBatchIndex = 0;
// insert Person and Address records onto PeopleStore and AddressStore in batch (bulk insert!)
for (int i = 1; i <= MaxCount; i++)
{
Address addr = new Address();
addr.AddressID = (int)AddressStore.GetNextSequence();
addr.City = "Fremont";
addr.Country = "USA";
addr.State = "California";
addr.Street = string.Format("143{0} LoveLane", i);
addr.ZipCode = "99999";
AddressStore.Add(addr.AddressID, addr);
AddressIDs[AddressBatchIndex++] = addr.AddressID;
//** in this block we've caused People to be inserted in batch of 1000
if (AddressBatchIndex == AddressBatchCount)
{
//** insert People in batch of 1000
int PhoneCtr = 1000;
for (int AddressID = 0; AddressID < AddressIDs.Length; AddressID++)
{
Person p = new Person();
p.AddressID = AddressIDs[AddressID];
p.FirstName = string.Format("{0}Joe", p.AddressID);
p.LastName = "Peter";
p.PhoneNumber = string.Format("510-555-{0}", PhoneCtr++);
PeopleStore.Add(p.GetKey(), p);
}
AddressBatchIndex = 0;
}
}
// if last batch wasn't inserted yet, then insert it
if (AddressBatchIndex > 0)
{
for (int AddressID = 0; AddressID < AddressBatchIndex; AddressID++)
{
Person p = new Person();
p.AddressID = AddressIDs[AddressID];
p.FirstName = string.Format("Joe{0}", p.AddressID);
p.LastName = "Peter";
p.PhoneNumber = "510-555-9999";
PeopleStore.Add(p.GetKey(), p);
}
}
}
void Populate(ISortedDictionary <object, object> PeopleStore)
{
int ZipCodeCtr = 5000;
CacheRecord[] BatchedRecords = new CacheRecord[BatchCount];
int BatchedIndex = 0;
for (int i = 0; i < MaxCount; i++)
{
int pid = (int)PeopleStore.GetNextSequence();
Person p = new Person()
{
FirstName = string.Format("Joe{0}", pid),
LastName = string.Format("Peter{0}", pid)
};
BatchedRecords[BatchedIndex] = new CacheRecord()
{
p = p,
blob = new PersonBlob
{
Blob = new byte[PersonBlob.BlobAvgSize]
}
};
BatchedRecords[BatchedIndex].blob.Blob[0] = 1;
BatchedRecords[BatchedIndex].blob.Blob[5] = 54;
BatchedIndex++;
if (BatchedIndex == BatchCount)
{
for (int i2 = 0; i2 < BatchedIndex; i2++)
{
PeopleStore.Add(BatchedRecords[i2].p, BatchedRecords[i2].blob);
}
PeopleStore.Flush();
if (i % 500 == 0)
{
ZipCodeCtr++;
}
BatchedIndex = 0;
}
}
if (BatchedIndex > 0)
{
for (int i2 = 0; i2 < BatchedIndex; i2++)
{
PeopleStore.Add(BatchedRecords[i2].p, BatchedRecords[i2].blob);
}
PeopleStore.Flush();
}
}
private void SetupSqlCe()
{
_commandBuilder = new SqlCeCommandBuilder();
if (File.Exists("TestingData.sdf"))
{
File.Delete("TestingData.sdf");
}
var engine = new SqlCeEngine("Data Source=TestingData.sdf;Persist Security Info=False;");
engine.CreateDatabase();
_db = new SqlCeConnection(engine.LocalConnectionString);
_db.Open();
var formatter = new ProtobufValueFormatter();
_uut = new SqlCeSortedDictionary <string, string>(_tableName, _db, formatter, _commandBuilder);
}
void Populate(ObjectServer server,
ISortedDictionary <long, Person> PeopleStore,
int maxCount,
int seed
)
{
int ZipCodeCtr = 5000;
for (int i = seed; i < maxCount; i++)
{
if (i == maxCount - 2)
{
object o = 90;
}
int aid = i;
Address addr = new Address()
{
AddressID = aid,
Key = new AddressKey()
{
Street = string.Format("143{0} LoveLane", aid),
City = "Fremont",
Country = "USA",
State = "California",
ZipCode = ZipCodeCtr.ToString()
}
};
int pid = (int)PeopleStore.GetNextSequence();
Person p = new Person()
{
PersonID = pid,
AddressID = addr.AddressID,
Key = new PersonKey()
{
FirstName = string.Format("Joe{0}", pid),
LastName = string.Format("Peter{0}", pid)
},
PhoneNumber = "510-555-9999"
};
PeopleStore.Add(p.PersonID, p);
if (i % 5000 == 0)
{
ZipCodeCtr++;
PeopleStore.Flush();
}
}
}
void Populate(ISortedDictionary <long, Person> PeopleStore)
{
for (int i = 0; i < MaxCount; i++)
{
int pid = (int)PeopleStore.GetNextSequence();
Person p = new Person()
{
PersonID = pid,
Key = new PersonKey()
{
FirstName = string.Format("Joe{0}", pid),
LastName = string.Format("Peter{0}", pid)
},
PhoneNumber = "510-555-9999"
};
PeopleStore.Add(p.PersonID, p);
}
}
public EnumeratorKeysFilter(ISortedDictionary <TKey, TValue> store, TKey[] keys, bool lockWrap = false)
{
if (keys == null || keys.Length == 0)
{
throw new ArgumentNullException("keys");
}
if (store == null)
{
throw new ArgumentNullException("store");
}
_lockWrap = lockWrap;
if (lockWrap)
{
store.Locker.Lock(OperationType.Read);
}
_store = (ISortedDictionaryOnDisk)((SpecializedStoreBase)store).Collection.Clone();
_keys = keys;
}
public EnumerableEnumeratorFilter(ISortedDictionary <TKey, TValue> target,
IEnumerable <KeyValuePair <TSourceKey, TSourceValue> > source,
ExtractKey <TSourceKey, TSourceValue, TKey> sourceKeyExtractor = null,
bool lockWrap = false)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (source == null)
{
throw new ArgumentNullException("source");
}
_target = target;
_source = source;
_sourceKeyExtractor = sourceKeyExtractor;
_lockWrap = lockWrap;
}
void Populate(ISortedDictionary <int, Person> PeopleStore,
ISortedDictionary <int, Address> AddressStore, int MaxCount)
{
Person[] NewPeople = new Person[1000];
int NewPeopleIndex = 0;
for (int i = 0; i < MaxCount; i++)
{
Address addr = new Address();
addr.AddressID = (int)AddressStore.GetNextSequence();
addr.City = "Fremont";
addr.Country = "USA";
addr.State = "California";
addr.Street = string.Format("143{0} LoveLane", i);
addr.ZipCode = "99999";
AddressStore.Add(addr.AddressID, addr);
Person p = new Person();
p.AddressID = addr.AddressID;
p.FirstName = string.Format("Joe{0}", i);
p.LastName = "Peter";
p.PhoneNumber = "510-555-9999";
NewPeople[NewPeopleIndex++] = p;
//** Batch add New People each set of 1000
if (NewPeopleIndex == 1000)
{
foreach (Person np in NewPeople)
{
PeopleStore.Add((int)PeopleStore.CurrentSequence, np);
}
NewPeopleIndex = 0;
}
}
//** add any left over new People haven't been added yet...
if (NewPeopleIndex > 0)
{
for (int i2 = 0; i2 < NewPeopleIndex; i2++)
{
Person np = NewPeople[i2];
PeopleStore.Add((int)PeopleStore.CurrentSequence, np);
}
NewPeopleIndex = 0;
}
}
/// <summary>
/// Sample code that creates 50 tables and deletes 40 of them.
/// Reads all the records of the leftover 10 tables. Intention of
/// this example is to test table space recycling and to show to the
/// user feature to delete a table in SOP.
/// </summary>
public void Run()
{
Console.WriteLine("{0}: CollectionRecycling demo started...", DateTime.Now);
const int CollCount = 50;
ITransaction Trans;
IStoreFactory sf = new StoreFactory();
for (int i = 0; i < CollCount; i++)
{
string CollectionName = string.Format("People{0}", i);
ISortedDictionary <long, Person> store = sf.Get <long, Person>(Server.SystemFile.Store, CollectionName);
Trans = store.Transaction;
if (store.Count == 0)
{
Populate(store);
store.Flush();
//store.Dispose();
}
//else
// store.Dispose();
if (i >= 10)
{
//** get the table 5 tables "ago"
store = sf.Get <long, Person>(Server.SystemFile.Store, string.Format("People{0}", i - 5));
//** delete the table retrieved...
store.Delete();
}
Trans.Commit();
server.BeginTransaction();
}
for (int i = 0; i < CollCount; i++)
{
string CollectionName = string.Format("People{0}", i);
ISortedDictionary <long, Person> store = sf.Get <long, Person>(Server.SystemFile.Store, CollectionName);
if (store != null)
{
ReadAll(store);
//store.Dispose();
}
}
Console.WriteLine("{0}: CollectionRecycling demo ended...", DateTime.Now);
}
static void ReadRecords(ISortedDictionary <int, Person> store, int MaxCount, string Salt)
{
store.MoveFirst();
store.HintBatchCount = 99;
for (int i = 0; i < MaxCount; i++)
{
Person p = store.CurrentValue;
if (p == null ||
p.FirstName != string.Format("Joe{0}{1}", i, Salt))
{
Console.WriteLine("Error, data for iteration {0} not found.", i);
}
store.MoveNext();
}
if (store.EndOfTree())
{
Console.WriteLine("Store's End of tree reached.");
}
}
void ReadAll(ref ISortedDictionary <Person, PersonBlob> PeopleStore)
{
var personBatch = new Person[1000];
int Ctr = 0;
for (int i = 0; i < MaxCount; i++)
{
Ctr++;
var p = new Person()
{
FirstName = string.Format("Joe{0}", Ctr),
LastName = string.Format("Peter{0}", Ctr)
};
if (PeopleStore.AddIfNotExist(p, null))
{
Console.WriteLine("Failed! 'expected add to fail due to duplicate key. {0}", p.FirstName);
}
}
Console.WriteLine("Processed {0} records.", Ctr);
}
void ReadAll(ISortedDictionary <long, Person> PeopleStore)
{
if (PeopleStore.MoveFirst())
{
PeopleStore.HintBatchCount = 103;
int Ctr = 0;
do
{
Ctr++;
Person p = PeopleStore.CurrentValue;
} while (PeopleStore.MoveNext());
if (Ctr != PeopleStore.Count)
{
Console.WriteLine("Failed! Read {0}, expected {1}", Ctr, PeopleStore.Count);
}
else
{
Console.WriteLine("Read {0} items.", Ctr);
}
}
}
void ReadAll(ref ISortedDictionary <object, object> PeopleStore)
{
var personBatch = new Person[1000];
int Ctr = 0;
for (int i = 0; i < MaxCount; i++)
{
Ctr++;
var p = new Person()
{
FirstName = string.Format("Joe{0}", Ctr),
LastName = string.Format("Peter{0}", Ctr)
};
var personBlob = PeopleStore[p];
if (personBlob == null)
{
Console.WriteLine("Failed! 'can't find person {0}.", p.FirstName);
}
}
Console.WriteLine("Processed {0} records.", Ctr);
}
/// <summary>
/// Shows how to store two different kinds of entities(People & Addresses)
/// on two Object Stores residing on two different Files.
///
/// NOTE: target folder paths (c:\SopBin & c:\SopBin2) should exist before running this program or else, it will
/// throw when opening the Files due to path not found.
/// </summary>
public static void Run()
{
Console.WriteLine("{0}: MultipleFiles demo started...", DateTime.Now);
MultipleFiles MultipleFiles = new MultipleFiles();
ISortedDictionary <int, Person> PeopleStore = MultipleFiles.GetObjectStore <Person>("People");
ISortedDictionary <int, Address> AddressStore = MultipleFiles.GetObjectStore <Address>("Address", "OFile2",
"SopBin2\\oFile2.dta");
const int MaxCount = 25000;
if (PeopleStore.Count == 0)
{
MultipleFiles.Populate(PeopleStore, AddressStore, MaxCount);
}
else
{
Console.WriteLine("Processing {0} People", PeopleStore.Count);
MultipleFiles.Stress(PeopleStore, AddressStore, MaxCount);
MultipleFiles.ReadAll(PeopleStore, AddressStore, MaxCount);
}
PeopleStore.Transaction.Commit();
Console.WriteLine("{0}: MultipleFiles demo ended...", DateTime.Now);
}
