Tutorial_09_CompositeKeys() { //---------------------------------------------------------------------------------------------------------- // Create Stash Client StashClient <EmployeeCompensation> client = StashConfiguration.GetClient <EmployeeCompensation>(); client.CreateTableIfNotExist(); //---------------------------------------------------------------------------------------------------------- // Populate the table with 10 years of salary information int nbrOfYears = 10; DateTime today = DateTime.Now.ToUniversalTime(); DateTime hireDate = today.AddYears(-nbrOfYears); Guid employeeId = Guid.NewGuid(); // Insert 10 years of data, such that each year the salary goes up by 5000. for (int yr = 0; yr < nbrOfYears; ++yr) { client.Insert( new EmployeeCompensation { EmployeeId = employeeId, CompDate = new CompensationEvent { CompensationType = CompensatationTypeValue.Salary, Date = hireDate.AddYears(yr) }, Amount = 65000 + (yr * 5000) }); } //---------------------------------------------------------------------------------------------------------- // Populate the table with the last 12 months of commission information int nbrOfMths = 12; // Insert 12 months of data, such that each year the commission goes up by 50. for (int mth = 0; mth < nbrOfMths; ++mth) { client.Insert( new EmployeeCompensation { EmployeeId = employeeId, CompDate = new CompensationEvent { CompensationType = CompensatationTypeValue.Commission, Date = today.AddMonths(-mth) }, Amount = 1000 + (mth * 50) }); } //---------------------------------------------------------------------------------------------------------- // Get the last salary EmployeeCompensation employeeCompensation = client .CreateQuery() .Where(e => e.EmployeeId == employeeId && e.CompDate == new CompensationEvent { CompensationType = CompensatationTypeValue.Salary }) // no need to specify the latest date, we get the first row, which // has the latest date. .Take(1) // first row .FirstOrDefault(); // verify we got the last date and last salary amount Assert.IsTrue(employeeCompensation.CompDate.Date.Date == hireDate.Date.AddYears((nbrOfYears - 1))); Assert.IsTrue(employeeCompensation.Amount == 65000 + ((nbrOfYears - 1) * 5000)); // How does this work? // Stash converts the "Compensation Type == 'S'" into // "RowKey >= 'S' and RowKey < 'T'" and asks to only return the first one (Take(1)) // In this case the last dated event is the first row, since the date is morphed // to the number of days before an arbitrary end date, such that the morphed date is // effectively in reverse order //---------------------------------------------------------------------------------------------------------- // Get all the commissions List <EmployeeCompensation> commissions = client .CreateQuery() .Where(e => e.EmployeeId == employeeId && e.CompDate == new CompensationEvent { CompensationType = CompensatationTypeValue.Commission }) // no need to specify the date, we get all the commissions // for the employee because again the query mapped the '==' to a range '>= and <'. .ToList(); Assert.IsTrue(commissions.Count == nbrOfMths); //---------------------------------------------------------------------------------------------------------- // Get commissions for the 4 months, prior to the last 4 months commissions = client .CreateQuery() .Where(e => e.EmployeeId == employeeId && e.CompDate >= new CompensationEvent { CompensationType = CompensatationTypeValue.Commission, Date = today.AddDays(-5).AddMonths(-8) } && e.CompDate <= new CompensationEvent { CompensationType = CompensatationTypeValue.Commission, Date = today.AddDays(-5).AddMonths(-4) } ) .ToList(); Assert.IsTrue(commissions.Count == 4); // How does this work? // Stash converts the query from a '>= X && < Y' to // < X && >= Y because the morpher indicated that 'IsCollationEquivalent' was false. // otherwise this query would have returned no rows because the range is inverted. //---------------------------------------------------------------------------------------------------------- }
Tutorial_08_Context() { //---------------------------------------------------------------------------------------------------------- // Create Stash Client and get a new context StashClient <Employee> client = StashConfiguration.GetClient <Employee>(); client.CreateTableIfNotExist(); StashContext <Employee> context = client.GetContext(); //---------------------------------------------------------------------------------------------------------- // Create instances of the class, place in the context and commit the changes. const int insertCount = 10; string departmentDev = Guid.NewGuid().ToString(); // create n employees and insert into the context Enumerable .Range(1, insertCount) .Select( idx => { Employee employee = new Employee { Department = departmentDev, EmployeeId = Guid.NewGuid().ToString(), Name = "John Doe", SkillLevel = 8, DateOfBirth = new DateTime(1990 - idx, 1, 1) }; // update the private field employee.SetAnnualSalary(); return(employee); }) .ToList() .ForEach( item => context.Insert(item)); // validate the the context now contains n items with the correct state. int contextInsertCount = context .GetTrackedEntities(EntityState.Inserted) .Count; Assert.IsTrue(contextInsertCount == insertCount); // commit the context // CommitStrategy.Serial, commits each insert as a single request // This is the default strategy and need not be passed in - context.Commit() would work the same context.Commit(CommitStrategy.Serial); // On a successful commit, the state of the entity changes to EntityState.Unchanged. // validate that the context contains n items with the correct state int contextUnchangedState = context .GetTrackedEntities(EntityState.Unchanged) .Count; Assert.IsTrue(contextInsertCount == contextUnchangedState); //---------------------------------------------------------------------------------------------------------- // The context continues to hold on to the entities so it is often a good idea to either clear the context // if the entities are no longer needed or better still to just create a new context. //---------------------------------------------------------------------------------------------------------- // Get a new context and query for the rows we inserted earlier by using the same partition key, // departmentDev context = client.GetContext(); context.CreateQuery().Where(emp => emp.Department == departmentDev).ToList(); // Confirm we have the corrent number of items in the context Assert.IsTrue(context.GetTrackedEntities().Count == insertCount); // Make changes to this collection of employees in the context, modifying some and deleting the others. int entityIdx = 0; int updateCount = 0; int deleteCount = 0; context .GetTrackedEntities() .ForEach( entityDescriptor => { Employee employee = entityDescriptor.Entity; if (entityIdx % 3 == 0) { context.Delete(employee); // delete every 3rd one ++deleteCount; } else // update the others { ++employee.SkillLevel; employee.SetAnnualSalary(); // change the salary of of the employee context.Update(employee); // and update in the context ++updateCount; } ++entityIdx; }); // Commit the context, this time use the Parallel strategy. // The Parallel strategy will perform all requests in parallel. In the event of an error, // a single aggregate StashAggregateException is returned containing one or more of the errors. context.Commit(CommitStrategy.Parallel); // Performing a delete will remove an entity form the context. Validate this. Assert.IsTrue(context.GetTrackedEntities().Count == insertCount - deleteCount); //---------------------------------------------------------------------------------------------------------- // Now delete all the other entities in the context context.GetTrackedEntities().ForEach( entityDescriptor => context.Delete(entityDescriptor.Entity)); // Commit the context, this time use the batch strategy. // In a nutshell, Batch is a mode supported by Azure table storage which allows, // a number and size limited request to be made. // Batch is only allowed on entities within the same Partition and has an all or none success guarantee. context.Commit(CommitStrategy.Batch); // If all were deleted successfully the context should not be tracking any entities. Assert.IsTrue(context.GetTrackedEntities().Count == 0); //---------------------------------------------------------------------------------------------------------- // So far so good. This concludes this part of the tutorial. Go Stash! }
Tutorial_01_Implicit_JobApplicant() { //---------------------------------------------------------------------------------------------------------- // Create the Stash Client. // Our helper class offers various flavors of this. StashClient <JobApplicant> client = StashConfiguration.GetClient <JobApplicant>(); //---------------------------------------------------------------------------------------------------------- // Create the corresponding table or confirm that it exists // The table name can be inferred using various methods. In this case it is inferred from the class name, // 'JobApplicant'. client.CreateTableIfNotExist(); //---------------------------------------------------------------------------------------------------------- // Create an instance of the class we want to Stash JobApplicant dataWritten = new JobApplicant { PartitionKey = "A", RowKey = Guid.NewGuid().ToString(), Name = "John Doe", Skill_Level = 1 }; //---------------------------------------------------------------------------------------------------------- // Stash it client.Insert(dataWritten); //---------------------------------------------------------------------------------------------------------- // Read back the data, using the partition and row key, no need to use LINQ here. JobApplicant dataRead = client.Get(dataWritten.PartitionKey, dataWritten.RowKey); //---------------------------------------------------------------------------------------------------------- // Verify we got back what we put in Assert.IsTrue(dataWritten.Equals(dataRead)); //---------------------------------------------------------------------------------------------------------- // Lets change the SkillLevel and Update dataWritten.Skill_Level += 1; client.Update(dataWritten); //---------------------------------------------------------------------------------------------------------- // Read back the data but this time lets use LINQ dataRead = client.CreateQuery() .Where(imp => imp.PartitionKey == dataWritten.PartitionKey && imp.RowKey == dataWritten.RowKey) .FirstOrDefault(); //---------------------------------------------------------------------------------------------------------- // Again verify that we got back what we put in Assert.IsTrue(dataWritten.Equals(dataRead)); //---------------------------------------------------------------------------------------------------------- // now delete the entity client.Delete(dataWritten); //---------------------------------------------------------------------------------------------------------- // And verify that it was actually deleted // by attempting to read back the data var queryable = from imp in client.CreateQuery() where imp.PartitionKey == dataWritten.PartitionKey && imp.RowKey == dataWritten.RowKey select imp; Assert.IsTrue(queryable.ToList().Count == 0); //---------------------------------------------------------------------------------------------------------- // So far so good. This concludes this part of the tutorial. Go Stash! }
Tutorial_06_Collections() { //---------------------------------------------------------------------------------------------------------- // Create a Stash Client StashClient <EmployeeSkills> client = StashConfiguration.GetClient <EmployeeSkills>(); client.CreateTableIfNotExist(); //---------------------------------------------------------------------------------------------------------- // Lets create an instance of the class we what to 'stash' const string departmentDev = "Dev"; const string ssn = "123456789"; EmployeeSkills dataWritten = new EmployeeSkills { Department = departmentDev, EmployeeId = Guid.NewGuid().ToString(), Name = "John Doe", SkillLevel = 8, DateOfBirth = new DateTime(1990, 1, 1), SSN = ssn, Salutation = Salutation.Ms }; // update the private field dataWritten.SetAnnualSalary(); // Populate Languages, certification and salary history dataWritten.Languages = new List <ProgramingLanguages> { ProgramingLanguages.Assembly, ProgramingLanguages.VisualBasic }; const string cert0 = "MSSQL", cert1 = "MSCPP", cert2 = "MSRP"; dataWritten.Certifications = new ArrayList { cert0, cert1, cert2 }; dataWritten.SalaryHistory = new SalaryInfo[] { new SalaryInfo { DateStart = new DateTime(2009, 1, 1), DateEnd = new DateTime(2010, 1, 1), Salary = 100000 }, new SalaryInfo { DateStart = new DateTime(2010, 1, 1), DateEnd = new DateTime(2012, 1, 1), Salary = 110000 }, }; dataWritten.MysteryNumbers = new int[] { 3, 2, 1, 0 }; //---------------------------------------------------------------------------------------------------------- // Stash it client.Insert(dataWritten); //---------------------------------------------------------------------------------------------------------- // Read back the data EmployeeSkills dataRead = client.Get(dataWritten.Department, dataWritten.EmployeeId); //---------------------------------------------------------------------------------------------------------- // Verify we got back what we put in Assert.IsTrue(dataWritten.Equals(dataRead)); //---------------------------------------------------------------------------------------------------------- // Verify exactly what was written to table storage by using the Generic Pool class we wrote // earlier. // set this up to target the correct table storage entity set StashClient <GenericPool> clientGenericPool = StashConfiguration.GetClient <GenericPool>( new StashClientOptions { OverrideEntitySetName = o => "EmployeeSkills", OverrideEntitySetNameIsDynamic = false, Feedback = StashConfiguration.TraceFeedback, }); GenericPool dataPool = clientGenericPool.Get( dataRead.Department, dataRead.EmployeeId); // All collection items are suffixed with the index base 0, in the format "_000". // Because the "_" is used for demarcating collection indexes, explicit defined members are not allowed // to have the embedded "_" character in the table property name. // Test for languages Assert.IsTrue( dataPool.Pool.Where( kv => kv.Key == "Languages_000" && ((ProgramingLanguages)kv.Value == ProgramingLanguages.Assembly)).ToList().Count == 1); Assert.IsTrue( dataPool.Pool.Where( kv => kv.Key == "Languages_001" && ((ProgramingLanguages)kv.Value == ProgramingLanguages.VisualBasic)).ToList().Count == 1); // Test for certification Assert.IsTrue( dataPool.Pool.Where( kv => kv.Key == "Certifications_000" && ((string)kv.Value == cert0)).ToList().Count == 1); Assert.IsTrue( dataPool.Pool.Where( kv => kv.Key == "Certifications_001" && ((string)kv.Value == cert1)).ToList().Count == 1); Assert.IsTrue( dataPool.Pool.Where( kv => kv.Key == "Certifications_002" && ((string)kv.Value == cert2)).ToList().Count == 1); // Test salary history - key only Assert.IsTrue( dataPool.Pool.Where( kv => kv.Key == "SalaryHistory_000").ToList().Count == 1); Assert.IsTrue( dataPool.Pool.Where( kv => kv.Key == "SalaryHistory_001").ToList().Count == 1); // Mystery numbers ... well they were persisted using the DataContract Serializer // and persisted as XML as a single table property. Assert.IsTrue( dataPool.Pool.Where( kv => kv.Key == "MysteryNumbers").ToList().Count == 1); //---------------------------------------------------------------------------------------------------------- // now delete the entity client.Delete( departmentDev, dataWritten.EmployeeId); //---------------------------------------------------------------------------------------------------------- // And verify that it was actually deleted // by attempting to read back the data var queryable = from imp in client.CreateQuery() where imp.Department == dataWritten.Department && imp.EmployeeId == dataWritten.EmployeeId select imp; Assert.IsTrue(queryable.ToList().Count == 0); //---------------------------------------------------------------------------------------------------------- // So far so good. This concludes this part of the tutorial. Go Stash! }
Tutorial_03_Explicit_Employee() { //---------------------------------------------------------------------------------------------------------- // Create the Stash Client. StashClient <Employee> client = StashConfiguration.GetClient <Employee>(); //---------------------------------------------------------------------------------------------------------- // Create the underlying table if it does not already exists client.CreateTableIfNotExist(); //---------------------------------------------------------------------------------------------------------- // Create an instance of the class const string departmentDev = "Dev"; Employee dataWritten = new Employee { Department = departmentDev, EmployeeId = Guid.NewGuid().ToString(), Name = "John Doe", SkillLevel = 8, DateOfBirth = new DateTime(1990, 1, 1) }; // update the private field dataWritten.SetAnnualSalary(); //---------------------------------------------------------------------------------------------------------- // Stash it client.Insert(dataWritten); // Note: On inserts, updates and merges, the ETag is overwritten from the ETag returned to keep the data // in sync. //---------------------------------------------------------------------------------------------------------- // And read it back Employee dataRead = client.Get(dataWritten.Department, dataWritten.EmployeeId); //---------------------------------------------------------------------------------------------------------- // Verify we got back what we put in Assert.IsTrue(dataWritten.Equals(dataRead)); // Verify that the 2 ETags are identical Assert.IsTrue(dataRead.ETagInternal == dataWritten.ETagInternal); //---------------------------------------------------------------------------------------------------------- // Change the Skill level and update the Stash dataWritten.SkillLevel += 1; dataWritten.SetAnnualSalary(); client.Update(dataWritten); //---------------------------------------------------------------------------------------------------------- // Read back the data but this time lets use LINQ Employee dataReadUpdated = client.CreateQuery() .Where(imp => imp.Department == departmentDev && imp.EmployeeId == dataWritten.EmployeeId) .FirstOrDefault(); //---------------------------------------------------------------------------------------------------------- // Again verify that we got back what we put in Assert.IsTrue(dataWritten.Equals(dataReadUpdated)); // Verify that the 2 ETags are identical Assert.IsTrue(dataWritten.ETagInternal == dataReadUpdated.ETagInternal); //---------------------------------------------------------------------------------------------------------- // now attempt to update the data read the first time around // this should fail and throw an exception since the data was updated since the row was last read and // so has a stale ETag. // Uses the implied update mode here by default. That is, if the StashETag attribute is applied to a // member in the class, implies ETag must match, bool isSuccess; try { client.Update(dataRead); isSuccess = false; } catch (Exception ex) { Assert.IsTrue((ex as StashException).Error == StashError.ETagMatchFailed); isSuccess = true; } Assert.IsTrue(isSuccess); //---------------------------------------------------------------------------------------------------------- // attempt to update it again but this time ignore ETag matching. This should succeed. // and dataRead has the latest ETag client.UpdateUnconditional(dataRead); //---------------------------------------------------------------------------------------------------------- // now attempt to delete the entity using the data written entity // this should fail and throw an exception since the data was recently updated and so has a new ETag // Uses the implied update mode here by default. That is, if the StashETag attribute is applied to a // member in the class, implies ETag must match, try { client.Delete(dataReadUpdated); isSuccess = false; } catch (Exception ex) { Assert.IsTrue((ex as StashException).Error == StashError.ETagMatchFailed); isSuccess = true; } Assert.IsTrue(isSuccess); //---------------------------------------------------------------------------------------------------------- // now delete the entity unconditionally without the need for ETag Matching. // Can instead also use client.DeleteUnconditional here too. client.Delete(dataRead, ETagMatch.Unconditional); //---------------------------------------------------------------------------------------------------------- // And verify that it was actually deleted // by attempting to read back the data var queryable = from imp in client.CreateQuery() where imp.Department == dataWritten.Department && imp.EmployeeId == dataWritten.EmployeeId select imp; Assert.IsTrue(queryable.ToList().Count == 0); //---------------------------------------------------------------------------------------------------------- // Essentially the ETag gist is this. // Define and decorate a member in your type with an ETag if you want to optimistic concurrency support. // Stash will keep you ETag in sync across inserts, updates and merges. // There are multiple ways to implicitly override ETag matching if that is what is wanted. // The implicit way to disable optimistic concurrency support is not to define an ETag member. //---------------------------------------------------------------------------------------------------------- // So far so good. This concludes this part of the tutorial. Go Stash! }
Tutorial_04_DictionaryPool() { //---------------------------------------------------------------------------------------------------------- // Create a Stash Client for the Employee class StashClient <Employee> clientEmployee = StashConfiguration.GetClient <Employee>(); clientEmployee.CreateTableIfNotExist(); //---------------------------------------------------------------------------------------------------------- // Create an StashClient for the generic pool class, // Since we want to read and write to the Employee table, notice how we setup the correct EntityName in // the StashClientOptions. Otherwise the azure table implied would be "GenericPool". // // The call back method of naming the table has flexible capabilities. It can be used to determine // the table name dynamically based on the data in the object instance. // In this case it is used statically and called only once. StashClient <GenericPool> clientGenericPool = StashConfiguration.GetClient <GenericPool>( new StashClientOptions { OverrideEntitySetName = o => "Employee", OverrideEntitySetNameIsDynamic = false, Feedback = StashConfiguration.TraceFeedback, }); //---------------------------------------------------------------------------------------------------------- // Stash an Employee const string departmentDev = "Dev"; Employee dataEmployee = new Employee { Department = departmentDev, EmployeeId = Guid.NewGuid().ToString(), Name = "John Doe", SkillLevel = 8, DateOfBirth = new DateTime(1990, 1, 1) }; dataEmployee.SetAnnualSalary(); clientEmployee.Insert(dataEmployee); //---------------------------------------------------------------------------------------------------------- // and read it back thru the GenericPool GenericPool dataPool = clientGenericPool.Get( dataEmployee.Department, dataEmployee.EmployeeId); //---------------------------------------------------------------------------------------------------------- // Verify we got back what we put in via the Employee type. Assert.IsTrue( dataPool.PrimaryKey == dataEmployee.Department && dataPool.SecondaryKey == dataEmployee.EmployeeId && dataPool.Pool["AnnualSalary"].Equals(dataEmployee.GetAnnualSalary()) && dataPool.Pool["Birthday"].Equals(dataEmployee.DateOfBirth) && dataPool.Pool["SkillLevel"].Equals(dataEmployee.SkillLevel) && dataPool.Pool["Name"].Equals(dataEmployee.Name) && dataPool.Pool.Count == 4 + 1); // + 1 to the ETag //---------------------------------------------------------------------------------------------------------- // Make a few changes and update dataPool.Pool["Name"] = "Lucifure"; // name change dataPool.Pool["Unique"] = Guid.NewGuid(); // new field clientGenericPool.Update(dataPool); // Note: Updates, Merges etc keep the original objects in sync with the latest ETags. // Even if an ETag is not specified for the type, if the type supports a Pool, // the ETag is maintained and synched in the pool //---------------------------------------------------------------------------------------------------------- // Read back the data GenericPool dataPoolRead = clientGenericPool.CreateQuery() .Where(imp => imp.PrimaryKey == dataEmployee.Department && imp.SecondaryKey == dataEmployee.EmployeeId) .FirstOrDefault(); //---------------------------------------------------------------------------------------------------------- // and verify that we got back what we put in Assert.IsTrue( dataPool.PrimaryKey == dataPoolRead.PrimaryKey && dataPool.SecondaryKey == dataPoolRead.SecondaryKey && StashHelper.DictionaryEquals( dataPool.Pool, dataPoolRead.Pool)); //---------------------------------------------------------------------------------------------------------- // Merge can be performed very efficiently with a StashPool. Only include the tables properties // to be merge in the dictionary. No need to null out members or defined nullable value type members. // Create a new pool with just the objects of interest Dictionary <string, object> pool = new Dictionary <string, object>(); // save the current etag (for now and later) string etagPreMerge = dataPoolRead.Pool[Literal.ETag].ToString(); pool["Name"] = "Stash"; // new value to merge pool[Literal.ETag] = etagPreMerge; // get the ETag too // create a new pool object for merging. GenericPool dataPoolMerged = new GenericPool { PrimaryKey = dataPoolRead.PrimaryKey, SecondaryKey = dataPoolRead.SecondaryKey, Pool = pool }; clientGenericPool.Merge(dataPoolMerged, ETagMatch.Must); // force ETag matching. // read back and verify GenericPool dataPoolMergedRead = clientGenericPool.Get( dataPoolMerged.PrimaryKey, dataPoolMerged.SecondaryKey); // validate Assert.IsTrue(dataPoolMergedRead.Pool.Count == dataPoolRead.Pool.Count && dataPoolMergedRead.Pool["Name"] as String == "Stash"); //---------------------------------------------------------------------------------------------------------- // attempt to merge again, replacing the current ETag with the old one. bool isSuccess; try { // use the defunct etag to exhibit this dataPoolMerged.Pool[Literal.ETag] = etagPreMerge; clientGenericPool.Merge(dataPoolMerged); isSuccess = false; } catch (Exception ex) { // Merge fails because the ETag was old and did not match. Assert.IsTrue((ex as StashException).Error == StashError.ETagMatchFailed); isSuccess = true; } Assert.IsTrue(isSuccess); //---------------------------------------------------------------------------------------------------------- // attempt to merge yet again, this time by disabling ETag matching. clientGenericPool.Merge(dataPoolMerged, ETagMatch.Unconditional); //---------------------------------------------------------------------------------------------------------- // now attempt to delete the entity try { clientGenericPool.Delete(dataPoolMergedRead); // Implicit ETag matching, will make this fail too // because the last update changed the ETag isSuccess = false; } catch (Exception ex) { Assert.IsTrue((ex as StashException).Error == StashError.ETagMatchFailed); isSuccess = true; } Assert.IsTrue(isSuccess); //---------------------------------------------------------------------------------------------------------- // Do an unconditional delete clientGenericPool.DeleteUnconditional(dataPoolMergedRead); //---------------------------------------------------------------------------------------------------------- // And verify that it was actually deleted // by attempting to read back the data var queryable = from emp in clientEmployee.CreateQuery() where emp.Department == dataEmployee.Department && emp.EmployeeId == dataEmployee.EmployeeId select emp; Assert.IsTrue(queryable.ToList().Count == 0); //---------------------------------------------------------------------------------------------------------- // So far so good. This concludes this part of the tutorial. Go Stash! }
Tutorial_07_LargeData() { //---------------------------------------------------------------------------------------------------------- // Create Stash Client StashClient <EmployeeResume> client = StashConfiguration.GetClient <EmployeeResume>(); client.CreateTableIfNotExist(); //---------------------------------------------------------------------------------------------------------- // Lets create an instance of the class we what to 'stash' const string departmentDev = "Dev"; EmployeeResume dataWritten = new EmployeeResume { Department = departmentDev, EmployeeId = Guid.NewGuid().ToString(), // 1 char = 2 bytes so this random string is 2.5 time the size of a table property Text = BuildString((int)(32 * 1024 * 2.5)), // almost 2 time the size of a table property Photograph = new byte[(int)(64 * 1024 * 1.9)], }; // generate random bytes for the photograph (new Random()).NextBytes(dataWritten.Photograph); //---------------------------------------------------------------------------------------------------------- // Stash it client.Insert(dataWritten); //---------------------------------------------------------------------------------------------------------- // Read back the data EmployeeResume dataRead = client.Get(dataWritten.Department, dataWritten.EmployeeId); //---------------------------------------------------------------------------------------------------------- // Verify we got back what we put in Assert.IsTrue(dataWritten.Equals(dataRead)); //---------------------------------------------------------------------------------------------------------- // Verify exactly what was written to table storage by using the Generic Pool class we wrote // earlier. // set this up to target the correct table storage entity set StashClient <GenericPool> clientGenericPool = StashConfiguration.GetClient <GenericPool>( new StashClientOptions { OverrideEntitySetName = o => typeof(EmployeeResume).Name, OverrideEntitySetNameIsDynamic = false, Feedback = StashConfiguration.TraceFeedback, }); GenericPool dataPool = clientGenericPool.Get( dataRead.Department, dataRead.EmployeeId); // All split items are suffixed with the index base A, in the format "_A". // Because the "_" is used for demarcating collection indexes, explicit defined members are not allowed // to have the embedded "_" character in the table property name. // Test for Text Assert.IsTrue( dataPool.Pool.Where( kv => kv.Key.IndexOf("Text_") == 0).ToList().Count == 3); Assert.IsTrue( dataPool.Pool.Where( kv => kv.Key.IndexOf("Photograph_") == 0).ToList().Count == 2); //---------------------------------------------------------------------------------------------------------- // now delete the entity client.Delete( departmentDev, dataWritten.EmployeeId); //---------------------------------------------------------------------------------------------------------- // And verify that it was actually deleted // by attempting to read back the data var queryable = from imp in client.CreateQuery() where imp.Department == dataWritten.Department && imp.EmployeeId == dataWritten.EmployeeId select imp; Assert.IsTrue(queryable.ToList().Count == 0); //---------------------------------------------------------------------------------------------------------- // So far so good. This concludes this part of the tutorial. Go Stash! }
Tutorial_05_Morphing_EmployeeInfo() { //---------------------------------------------------------------------------------------------------------- // Create a Stash Client StashClient <EmployeeInfo> client = StashConfiguration.GetClient <EmployeeInfo>(); client.CreateTableIfNotExist(); //---------------------------------------------------------------------------------------------------------- // Create an instance of the class we what to Stash const string departmentDev = "Dev"; const string ssn = "123456789"; EmployeeInfo dataWritten = new EmployeeInfo { Department = departmentDev, EmployeeId = Guid.NewGuid().ToString(), Name = "John Doe", SkillLevel = 8, DateOfBirth = new DateTime(1990, 1, 1), SSN = ssn, Salutation = Salutation.Dr }; // update the private field dataWritten.SetAnnualSalary(); //---------------------------------------------------------------------------------------------------------- // Stash it client.Insert(dataWritten); //---------------------------------------------------------------------------------------------------------- // Read back the data EmployeeInfo dataRead = client.Get(dataWritten.Department, dataWritten.EmployeeId); //---------------------------------------------------------------------------------------------------------- // Verify we got back what we put in Assert.IsTrue(dataWritten.Equals(dataRead)); //---------------------------------------------------------------------------------------------------------- // Now let us verify exactly what was written to table storage by using the Generic Pool class we wrote // earlier. // set this up to target the correct table storage entity set StashClient <GenericPool> clientGenericPool = StashConfiguration.GetClient <GenericPool>( new StashClientOptions { OverrideEntitySetName = o => "EmployeeInfo", OverrideEntitySetNameIsDynamic = false, Feedback = StashConfiguration.TraceFeedback, }); GenericPool dataPool = clientGenericPool.Get( dataRead.Department, dataRead.EmployeeId); // validate that the SSN value got morphed in to a byte[] Assert.IsTrue(dataPool.Pool["SSN"].GetType() == typeof(byte[])); //---------------------------------------------------------------------------------------------------------- // Change the Skill level and update the Stash dataWritten.SkillLevel += 1; dataWritten.SetAnnualSalary(); // force an unconditional update since, dataWritten does not have a ETag. // Optionally copy over the ETag from dataRead. client.Update(dataWritten, ETagMatch.Unconditional); //---------------------------------------------------------------------------------------------------------- // Read back the data but this time lets use LINQ dataRead = client.CreateQuery() .Where(imp => imp.Department == departmentDev && imp.EmployeeId == dataWritten.EmployeeId) .FirstOrDefault(); //---------------------------------------------------------------------------------------------------------- // Again verify that we got back what we put in Assert.IsTrue(dataWritten.Equals(dataRead)); //---------------------------------------------------------------------------------------------------------- // now delete the entity client.Delete( departmentDev, dataWritten.EmployeeId); //---------------------------------------------------------------------------------------------------------- // And verify that it was actually deleted // by attempting to read back the data var queryable = from imp in client.CreateQuery() where imp.Department == dataWritten.Department && imp.EmployeeId == dataWritten.EmployeeId select imp; Assert.IsTrue(queryable.ToList().Count == 0); //---------------------------------------------------------------------------------------------------------- // So far so good. This concludes this part of the tutorial. Go Stash! }
Tutorial_02_Hybrid_TempHire() { //---------------------------------------------------------------------------------------------------------- // Create the Stash Client. StashClient <TempHire> client = StashConfiguration.GetClient <TempHire>(); //---------------------------------------------------------------------------------------------------------- // Create a table with the class name ('TempEmployee') or confirm that it exists client.CreateTableIfNotExist(); //---------------------------------------------------------------------------------------------------------- // Create an instance of the class we what to Stash TempHire dataWritten = new TempHire { PartitionKey = "B", RowKey = Guid.NewGuid().ToString(), Name = "Jill Doe", Skill_Level = 5, DateOfBirth = new DateTime(1990, 1, 1) }; // update the private field dataWritten.SetHourlyPay(); //---------------------------------------------------------------------------------------------------------- // Stash it client.Insert(dataWritten); //---------------------------------------------------------------------------------------------------------- // Read back the data TempHire dataRead = client.Get(dataWritten.PartitionKey, dataWritten.RowKey); //---------------------------------------------------------------------------------------------------------- // Verify we got back what we put in Assert.IsTrue(dataWritten.Equals(dataRead)); //---------------------------------------------------------------------------------------------------------- // Lets change the Skill level and update the Stash dataWritten.Skill_Level += 1; dataWritten.SetHourlyPay(); client.Update(dataWritten); //---------------------------------------------------------------------------------------------------------- // Read back the data but this time lets use LINQ dataRead = client.CreateQuery() .Where(imp => imp.PartitionKey == dataWritten.PartitionKey && imp.RowKey == dataWritten.RowKey) .FirstOrDefault(); //---------------------------------------------------------------------------------------------------------- // Again verify that we got back what we put in Assert.IsTrue(dataWritten.Equals(dataRead)); //---------------------------------------------------------------------------------------------------------- // now delete the entity client.Delete( dataWritten.PartitionKey, dataWritten.RowKey); //---------------------------------------------------------------------------------------------------------- // And verify that it was actually deleted // by attempting to read back the data var queryable = from imp in client.CreateQuery() where imp.PartitionKey == dataWritten.PartitionKey && imp.RowKey == dataWritten.RowKey select imp; Assert.IsTrue(queryable.ToList().Count == 0); //---------------------------------------------------------------------------------------------------------- // So far so good. This concludes this part of the tutorial. Go Stash! }