C# Db.GetItem方法代码示例

    public void ShouldBeThreadLocalStandardValuesProvider()
    {
      var templateId = ID.NewID;
      var itemId = ID.NewID;
      var fieldId = ID.NewID;

      var t1 = Task.Factory.StartNew(() =>
      {
        using (var db = new Db
                          {
                            new DbTemplate(templateId) { { fieldId, "$name" } },
                            new DbItem("Home", itemId, templateId)
                          })
        {
          Thread.Sleep(1000);
          db.GetItem(itemId)[fieldId].Should().Be("Home");
        }
      });

      var t2 = Task.Factory.StartNew(() =>
      {
        using (var db = new Db
                          {
                            new DbTemplate(templateId) { fieldId },
                            new DbItem("Home", itemId, templateId)
                          })
        {
          db.GetItem(itemId)[fieldId].Should().BeEmpty();
        }
      });

      t1.Wait();
      t2.Wait();
    }

    public void ShouldPropagateFieldsFromTheBaseTemplate()
    {
      // arrange
      ID templateId = ID.NewID;

      using (var db = new Db
      {
        this.baseTemplateOne,
        new DbTemplate("My Template", templateId) {BaseIDs = new[] {this.baseTemplateOne.ID}},
        new DbItem("home", ID.NewID, templateId)
      })
      {
        // act
        Item home = db.GetItem("/sitecore/content/home");
        Template template = TemplateManager.GetTemplate(templateId, db.Database);
        Template baseTemplate = TemplateManager.GetTemplate(this.baseTemplateOne.ID, db.Database);

        TemplateField titleField = baseTemplate.GetField("Title");

        // assert 

        // note: it should "just" work as Sitecore wil do all the looking up the templates chain
        template.GetFields(false).Should().NotContain(f => f.Name == "Title" || f.ID == titleField.ID);
        template.GetFields(true).Should().Contain(f => f.Name == "Title" && f.ID == titleField.ID);

        template.GetField("Title").Should().NotBeNull("template.GetField(\"Title\")");
        template.GetField(titleField.ID).Should().NotBeNull("template.GetField(titleField.ID)");

        home.Fields["Title"].Should().NotBeNull("home.Fields[\"Title\"]");
        home.Fields[titleField.ID].Should().NotBeNull("home.Fields[titleField.ID]");
      }
    }

    public void ShouldPropagateFieldsFromAllBaseTemplates()
    {
      // arrange
      ID myTemplateId = ID.NewID;

      using (var db = new Db
      {
        this.baseTemplateOne,
        this.baseTemplateTwo,
        this.baseTemplateThree,
        new DbTemplate("Main Template", myTemplateId) {BaseIDs = new[] {this.baseTemplateOne.ID, this.baseTemplateThree.ID}},
        new DbItem("home", ID.NewID, myTemplateId)
      })
      {
        // act
        Item home = db.GetItem("/sitecore/content/home");
        Template template = TemplateManager.GetTemplate(myTemplateId, db.Database);

        // assert

        // note: as noted above, fields propagation should "just" work
        home.Fields["Title"].Should().NotBeNull("home.Fields[\"Title\"]");
        home.Fields["Description"].Should().NotBeNull("home.Fields[\"Description\"]");

        template.GetField("Title").Should().NotBeNull("template.GetField(\"Title\")");
        template.GetField("Description").Should().NotBeNull("template.GetField(\"Description\")");
      }
    }

 public void ShouldCreateItemHierarchyAndReadChildByPath()
 {
   // arrange & act
   using (var db = new Db { new DbItem("parent") { new DbItem("child") } })
   {
     // assert
     db.GetItem("/sitecore/content/parent/child").Should().NotBeNull();
   }
 }

    public void ShouldGetLayoutField()
    {
      using (var db = new Db { new DbItem("home") })
      {
        var home = db.GetItem("/sitecore/content/home");

        FieldTypeManager.GetField(home.Fields[FieldIDs.LayoutField]).Should().BeOfType<LayoutField>();
        FieldTypeManager.GetFieldType("Layout").Type.Should().Be<LayoutField>();
      }
    }

    public void ShouldDeserializeNullBaseTemplateItem()
    {
      var item = new DsDbItem("/sitecore/content/New Item Without BaseTemplates");

      using (var db = new Db { item })
      {
        var linkedTemplate = db.GetItem(item.TemplateID);
        linkedTemplate.Should().NotBeNull();
        linkedTemplate.Template.Name.ShouldBeEquivalentTo("Template");
      }
    }

    public void ShouldGetField(string name, Type type)
    {
      using (var db = new Db
                        {
                          new DbItem("home") { new DbField("field") { Type = name } }
                        })
      {
        var home = db.GetItem("/sitecore/content/home");

        FieldTypeManager.GetField(home.Fields["field"]).Should().BeOfType(type);
        FieldTypeManager.GetFieldType(name).Type.Should().Be(type);
      }
    }

    public void ShouldNotTimeOutOnFailingFluentAssertion()
    {
      // arrange
      using (var db = new Db
      {
        new DbItem("home")
      })
      {
        var home = db.GetItem("/sitecore/content/home");

        Action assertion = () =>
        {
          try { home.Should().BeNull(); } catch { }
        };

        // act && assert
        assertion.ExecutionTime().ShouldNotExceed(1.Seconds());
      }
    }

    public void ShouldBeThreadLocalDb()
    {
      var t1 = Task.Factory.StartNew(() =>
        {
          using (var db = new Db { new DbItem("Home") })
          {
            Thread.Sleep(1000);
            db.GetItem("/sitecore/content/home").Should().NotBeNull("the Home item is expected");
          }
        });

      var t2 = Task.Factory.StartNew(() =>
        {
          using (var db = new Db())
          {
            db.GetItem("/sitecore/content/home").Should().BeNull("the Home item is not expected");
          }
        });

      t1.Wait();
      t2.Wait();
    }

    public void ShouldNotThrowOnGetTemplateFieldItem()
    {
      // arrange
      using (var db = new Db
                        {
                          new DbItem("home") { new DbField("field") }
                        })
      {
        var home = db.GetItem("/sitecore/content/home");

        // act
        FieldTypeManager.GetTemplateFieldItem(home.Fields["field"]);
      }
    }

 public void ShouldCreateItemOfFolderTemplate()
 {
   // arrange & act
   using (var db = new Db
                     {
                       new DbItem("Sample") { TemplateID = TemplateIDs.Folder }
                     })
   {
     // assert
     db.GetItem("/sitecore/content/sample").TemplateID.Should().Be(TemplateIDs.Folder);
   }
 }

    public void ShouldCreateAndFulfilCompositeFieldsStructure()
    {
      // arrange
      using (var db = new Db())
      {
        // act
        db.Add(new DbItem("item1") { { "field1", "item1-field1-value" }, { "field2", "item1-field2-value" } });
        db.Add(new DbItem("item2") { { "field1", "item2-field1-value" }, { "field2", "item2-field2-value" } });

        // assert
        db.GetItem("/sitecore/content/item1")["field1"].Should().Be("item1-field1-value");
        db.GetItem("/sitecore/content/item1")["field2"].Should().Be("item1-field2-value");
        db.GetItem("/sitecore/content/item2")["field1"].Should().Be("item2-field1-value");
        db.GetItem("/sitecore/content/item2")["field2"].Should().Be("item2-field2-value");
      }
    }

    public void ShouldCreateItemOfAnyVersion()
    {
      // arrange
      using (var db = new Db
                        {
                          new DbItem("home") { { "Title", "title v1" } }
                        })
      {
        var version2 = db.GetItem("/sitecore/content/home", "en", 2);

        // act
        using (new EditContext(version2))
        {
          version2["Title"] = "title v2";
        }

        // assert
        db.GetItem("/sitecore/content/home", "en", 1)["Title"].Should().Be("title v1");
        db.GetItem("/sitecore/content/home", "en", 2)["Title"].Should().Be("title v2");
      }
    }

    public void ShouldGetItemParent()
    {
      // arrange
      using (var db = new Db { new DbItem("item") })
      {
        // act
        var parent = db.GetItem("/sitecore/content/item").Parent;

        // assert
        parent.Paths.FullPath.Should().Be("/sitecore/content");
      }
    }

    public void ShouldDeserializeItemBasedOnTwoTemplates()
    {
      // arrange
      using (var db = new Db
                        {
                          new DsDbItem("/sitecore/content/New Composite Sample Item")
                        })
      {
        // act
        var item = db.GetItem("/sitecore/content/New Composite Sample Item");

        // assert
        item["Sample Field One"].Should().Be("Value One");
        item["Sample Field Two"].Should().Be("Value Two");
      }
    }