WinFS

  提示：此条目页的主题不是WinFX。

WinFS（簡稱為Windows Future Storage）是代號為數據存儲和管理系統，基於關係型數據庫，由Microsoft開發，首先表現在2003年作為一種先進的存儲子系統，為Microsoft Windows作業系統，正在設計毅力和管理結構化，半結構化以及非結構化數據。而WinFS包括一個關係型數據庫儲存的信息，並允許任何類型的信息被儲存在，只要有一個明確的模式，為型。個人資料項目，便可在相關的共同關係，要么推斷該系統基於某些屬性或已明確由用戶。由於該報告的數據有一個明確的模式，任何應用程序可以重用數據，並利用關係，相關的數據可以有效地組織以及發音。由於該系統知悉結構和意圖的信息，它可以用來製造複雜的查詢功能，使先進的檢索途徑是通過資料和集合各種數據項，利用它們之間的關係。
而微軟WinFS和它的共享型模式，使美國能夠騰出申請承認不同的數據類型，應用，還需要向編碼，使不同的數據類型。因此，它不會允許發展的一個單一的應用程序，可以查看或編輯所有數據類型，而是怎樣使WinFS的是應用，以了解結構的所有數據和提取信息，它可以使用。當WinFS的推出，在2003年專業開發者大會上，微軟還推出了一個視頻演示，命名iwish ，顯示樣機接口，顯示如何應用，將揭露界面，利用一個統一的類型系統。該概念表明，在視頻不等，從申請使用關係的項目，以動態地提供過濾選項來申請分組多種相關的數據類型，並使其在一個統一的陳述。
echnologies ，並將船上的一部分，在下一版的Windows作業系統。但後來決定將WinFS的船舶後，版Windows Vista ，但這一計劃被擱置，在2006年6月，它的一些構件技術集成到即將發布的ado.net和Microsoft SQL Server 。 ，而這是然後由觀察員將WinFS移植到是做了一個項目， 2006年11月，鮑爾默宣布WinFS的是仍處於開發階段，雖然目前尚不清楚這項技術會如何打算將被交付。

動機

許多檔案發現，就共同作業系統，包括了對NTFS文件系統是用於現代版本的Microsoft Windows ，儲存檔案和其他物品，只是作為一個流的字節，沒有或只有很少的資料，數據儲存在檔案。這種檔案系統，也只能提供一個單一的方式安排文件，即通過目錄和文件名。

因為一個文件系統沒有深入了解它的數據倉庫， 申請傾向於使用自己的，往往是專有的，文件格式。這阻礙了數據共享之間的多種應用。它變得難以創造申請流程資料，從多種類型的文件，因為程序員必須了解結構和語義的所有檔案。用常見的文件格式，是一種變通方法，以這個問題，而不是一個通用的解決方案;不能保證所有申請將使用的格式。數據與標準化模式，如XML文件和關係數據的票價更好，因為他們有一個標準化的結構和運行時間的要求。

此外，傳統的檔案系統，可以檢索和搜索數據為基礎，不僅對文件名，因為只有知識，它有關於數據是名字的檔案存儲這些數據。一個更好的解決辦法是標籤文件屬性形容他們。屬性，是歷史沿革有關文件，如文件類型（如文件，圖片，音樂創作者，等等） 。 這使得文件能夠被搜查，由它們的屬性，方法，不可能用一個文件夾層次，如作為尋找"圖片，其中有某人X "的。該屬性可以承認或者檔案系統native的，或透過一些延期。桌面搜索應用程序利用這個概念領先一步。他們中提取數據，包括屬性，從檔案和指數。提取數據，他們使用的過濾器，為每個文件格式。這使得檢索的基礎上，該文件的屬性和數據。

不過，這仍然不利於管理相關數據，作為互不相幹的項目沒有任何關係的界定。舉例來說，是不可能去尋找"的電話號碼，所有的人生活在阿卡普爾科，並每人有 100多露面，在我的照片集，並與我有一封電子郵件，上個月" 。這種搜索包含需要有一個數據模型，它有兩個語義，以及人際關係的數據定義。 WinFS的目的是要提供這樣的數據模型和運行時基礎設施，可以用來儲存數據以及之間的關係數據的項目，根據數據模型，這樣，在一個令人滿意的水平表現。

概況

WinFS的native的認識不同類型的數據，如圖片，電子郵件，文件，音頻，視頻，日曆，聯繫人等，而不僅僅是bytestreams與檔案系統。數據存儲和管理系統的實例的數據類型公認的，由WinFS的運行時間。數據是結構化的方式性能。舉例來說，比如一個簡歷類型，將表面上的數據，揭露某些性能如姓名，學歷，經驗，等等。每一項性能，可簡單的類型一樣，弦樂團，是整型或日期或複雜類型一樣接觸。不同的數據類型，揭露不同的屬性。此外， WinFS的，也允許不同的數據，事例就相關在一起，如一個文件和一個可以接觸相關的，由作者的關係。 人際關係，也暴露了作為屬性;舉例說，如果一份文件，是有關與A聯繫與創造的關係，那麼該文件將有一個創造的財產。當它被訪問時，雙方的關係是走過和相關數據返回。 追隨關係時，所有相關數據，可以得出。

一個電子郵件應用程序可以使用關係，以建立動態的過濾器，以營造不同意見的電子郵件，在樣機截圖

WinFS的促進數據共享與應用，使該數據類型，使所有的申請，並附上自己的模式 ，使任何應用程序，當它想用一個WinFS的類型，所使用的模式，可以找出結構的數據並利用這些資料。因此，申請已獲得所有數據和有關的制度，即使開發商沒有寫解析器認識到不同的數據格式。它也可以用關係及相關數據，以建立動態的過濾器，以目前資訊應用處理，以不同的方式。有關WinFS的空氣污染指數進一步文摘的任務存取數據。所有WinFS的類型暴露。淨額對象與性質的研究對象直接映射到屬性的數據類型。此外，讓不同的應用程序處理，同時數據共享，同時WinFS的數據，例如，而不是存放相同的數據在不同的文件，輕鬆同步不同商店時，數據變化是取消。 因此而WinFS幫助減少裁員。

進入所有數據在系統允許複雜檢索數據，以演出的所有數據項目管理的WinFS 。在舉例用上述（以下簡稱"的電話號碼，所有的人生活在阿卡普爾科，並每人有100多露面，在我的照片集，並與我有一封電子郵件，上個月" ），而WinFS可以導線主題的關係所有照片，以尋找聯繫的項目。同樣，它可以找到過濾所有郵件在過去一個月及上網的溝通關係，以達到接觸。共同接觸，然後再計算出從兩套結果和他們的電話號碼檢索進入合適的物業管接觸的物品。

WinFS ，它除了充分schematized數據（如XML和關係數據），支持半結構（如圖像，其中有一個鬆散的碼流結構加元）以及非結構化（如檔案），以及。它存儲非結構化成分直接作為檔案保存，而結構化數據，在結構化存儲。WinFS的內部採用了關係型數據庫來管理這些數據。但是，這並不限制數據，以專屬於任何特定的數據模型，如關係或等級，但可以任何良好定義的模式。有關 WinFS的運行圖，圖式，一關係模式， 通過定義表，它會存儲類型和主鍵和外鍵表示，將要求代表人際關係。而WinFS包括映射對象和XML模式的默認;映像其他模式需要具體規定。對象模式，是指定使用XML ; WinFS的生成代碼，以表面模式，作為淨班。 ado.net可用於直接指明關係模式，雖然映射到對象模式的需要，將提供給在表面上，作為班級。所有關係traversals演出作為一道對這些圖表。而WinFS還自動創建指標，對這些表格，以方便快速地獲取信息。指標大大加快加入，因此，遍歷關係，以檢索有關資料，是表現非常快。指標也被用來在尋找信息;檢索和查詢使用指標，使有關作業完成迅速，很像桌面搜索系統。

發展

發展WinFS的是擴大的一個特點是最初計劃在20世紀90年代初。被稱為對象文件系統，它本來是要被列入部分開羅。果寡糖是要具有強大的數據匯總功能 ，但在開羅的項目被擱置，而與開放式收費系統。然而，在後來的發展，最好的，一個存儲系統，將其稱之為存儲+ ，基於當時即將到來的SQL Server 8.0 ，是有計劃，其中定提供類似的聚集功能，也從來沒有兌現，類似科技，關聯文件系統（ RFS ）的，是為了推出與SQL Server 2000 。 但是，在SQL Server 2000中結束了作為未成年人的升級到SQL Server 7.0和rfs沒有得到執行。

不過，這個概念並沒有放棄，它只是演變而WinFS 。 WinFS的最初計劃納入Windows Vista中 ，並建立4051的Windows Vista ，那麼所謂的由它的代號為"長角" ，給開發商，在微軟專業開發者大會在2003年，包括WinFS的，但它受到了顯著的性能問題在2004年8月，微軟宣布將WinFS移植不會船舶與Windows Vista中，它反而會可作為一個可下載更新後， Vista的發布。

於2005年8月29日，微軟悄悄作了測試版1 WinFS的提供給MSDN用戶。它在Windows XP中，並要求。 .NET Framework運行。有關WinFS的宣傳片內容包括在system.storage名字空間。 測試被刷新對2005年12月1日至兼容2.0版的。 NET Framework。的WinFS Beta 2的是，計劃了一段時間後，在2006年 ，是要整合包括與Windows桌面搜索，使搜索結果包括結果，由雙方定期檔案和WinFS的商店，以及允許訪問的WinFS的數據用ado.net。

不過，對2006年6月23日，微軟WinFS團隊在微軟宣布WinFS的，將不再作為一種獨立的產品，和一些組件將帶來的大傘下的其它技術-例如ADO.NET Entity Framework 實體框架以及為支持非結構化數據並adminless的運作模式，到SQL Server的2008年，當時的代號為katmai。

與此宣布，大多數分析家認為WinFS的項目是被殺害。但在2006年11月， [鮑爾默]在接受採訪時說的WinFS正在積極開發，但整合到Windows代碼來後，才技術充分孵育但其後證實在接受媒體採訪Bill Gates ，並表示，微軟計劃遷移應用，如Windows Media Player ， Windows Photo Gallery ， Microsoft Office Outlook 等，以利用作為WinFS的數據存儲返回-結束。

?接??== 資料存放區 ==

架構

Architecture of the WinFS Stack

WinFS不是實體檔案系統；相反地，它在NTFS檔案系統之上提供系統化的資料模型建構能力。它仍然使用NTFS在實體檔案中儲存其資料。。 WinFS使用從SQL Server 2005衍生的關聯式引擎來提供資料關係機制。WinFS存放區僅是已設定FILESTREAM屬性的SQL Server資料庫(.MDF)檔案。這些檔案是儲存在磁碟區根目錄下名為"System Volume Information"的資料夾(此資料夾具有限制的存取權)下的"WinFS"子資料夾中，其名稱為這些存放區的GUID。

WinFS 堆疊的底層是WinFS Core，它會與檔案系統互動並提供檔案存取與定址能力。 關聯式引擎使用WinFS核心服務來提供結構化的存放區與其他服務(例如，鎖定將使用哪個WinFS執行階段來實作該功能。WinFS執行階段會公開服務(例如同步處理與規則)，其可用於同步處理WinFS存放區或在發生特定事件時執行特定動作。

WinFS是以服務的方式執行，此服務會執行三個處理程序 - 裝載關聯式資料存放區的WinFS.exe、裝載索引編製與查詢引擎的WinFSSearch.exe，以及與底層檔案系統互動的WinFPM.exe (WinFS File Promotion Manager)。您可以利用一組.NET Framework API來撰寫程式以存取其功能，這些.NET Framework API可讓應用程式定義自訂資料型別、定義資料之間的關係、儲存與擷取資訊，以及實作進階搜尋。 接著應用程式可以彙整資料，並將資料呈現給使用者。

資料存放區

WinFS將資料儲存在關聯式存放區中，這些存放區會公開為虛擬位置，稱為存放區。 WinFS存放區是通用存放庫，任何應用程式都可以在其中儲存資料，以及中繼資料、資料關係與結構描述。WinFS執行階段本身可以套用特定的資料關係；例如，若圖片的subject屬性與連絡人的name屬性相同，則WinFS可以在該連絡人與該圖片之間建立關聯。 資料之間的關係也可以由其他應用程式或使用者指定。

WinFS 提供一致性的存放區，但無法定義將儲存於存放區之資料的格式。但是，它支援以應用程式支援的特定格式寫入資料。前提是應用程式必須提供結構描述，以定義解譯檔案格式的方式。 例如，您可以新增結構描述以讓WinFS知道如何讀取(甚至是進一步搜尋或分析)特定檔案格式，例如PDF檔案。透過使用結構描述，任何應用程式都可以讀取由其他應用程式所建立的資料，而且不同的應用程式也可以透過共用結構描述以其他應用程式支援的格式來寫入資料。

您可以在一部電腦上建立多個WinFS存放區。 這樣可以獨立儲存不同類別的資料，例如，您可以將公司文件與私人文件儲存在不同的存放區中。根據預設，WinFS只提供一個存放區，其名稱為"DefaultStore"。 WinFS存放區是公開為殼層(shell)物件(類似虛擬資料夾)，此物件會動態產生存放區中的項目清單，並以資料夾檢視方式呈現這些項目。利用殼層物件也可以搜尋資料存放區中的資訊。

資料單位是以WinFS 項目的方式儲存在WinFS存放區中。 WinFS 項目與核心資料項目亦包含資料項目與其他資料之關聯的資訊。此關聯是以邏輯連結的方式儲存。連結指的是目前的項目與哪些資料項目關聯。換句話說，連結是用以指定資料與其他資料項目的關係。連結實體上是以連結識別碼來儲存，此識別碼指定資料關聯的名稱與用途，例如，所屬型別或組成要素。 連結識別碼是儲存為資料項目的屬性(attribute)。具有相同連結識別碼的所有物件將被視為相關物件。 您必須事先將XML 結構描述(定義將儲存在WinFS中之資料項目的結構)提供給WinFS執行階段。 在WinFS的Beta 1版本中，您必須先將結構描述組件新增到GAC，才能開始使用結構描述。

資料模型

WinFS模型資料會使用資料項目、其關聯、延伸(extension)與規則來規範其使用方式。 WinFS必須知道資料項目的類型與結構，才能將資料項目中儲存的資訊提供給要求該資訊的應用程式。這是透過使用結構描述來完成。對於即將儲存在WinFS中的每種資料項目類型，您必須提供對應的結構描述，以定義資料的類型、結構與關聯。這些結構描述是使用XML來定義。

預先定義的WinFS結構描述不僅包含文件、電子郵件、約會、工作、媒體、音訊、視訊等的結構描述；也包含系統結構描述，其中包括組態、程式與其他系統相關資料。 如果要讓應用程式在WinFS中儲存資料，但不想與其他應用程式共用該資料的結構，或這些資料可跨系統提供，則可以針對個別應用程式定義自訂結構描述。

型別系統

WinFS Type Hierarchy

檔案系統與WinFS之間最大的差異在於WinFS知道其所儲存之每個資料項目的型別。型別會指定資料項目的屬性(property)。WinFS型別系統與.NET Framework的類別與繼承概念緊密關聯。透過延伸與巢狀化任何預先定義的型別，即可建立新型別。

WinFS提供四種預先定義的基礎型別 – Items、Relationships、ScalarTypes 與 NestedTypes。 Item是可儲存的基礎資料物件，而Relationship則是兩個資料項目之間的關係或連結。因為所有WinFS項目都必須具有型別，儲存之項目的型別會定義其屬性(property)。Item 的屬性可以是 ScalarType(定義屬性可包含之資訊的最小單位)或 NestedType (多個ScalarTypes和/或NestedTypes的集合)。所有WinFS型別都以.NET CLR 類別的方式提供。

Any object represented as a data unit, such as contact, image, video, document etc, can be stored in a WinFS store as a specialization of the Item type. By default, WinFS provides Item types for Files, Contact, Documents, Pictures, Audio, Video, Calendar, and Messages. The File Item can store any generic data, which is stored in file systems as files. But unless an advanced schema is provided for the file, by defining it to be a specialized Item, WinFS will not be able to access its data. Such a file Item can only support being related to other Items.

Defining a new Type

A developer can extend any of these types, or the base type Item, to provide a type for his custom data. The data contained in an Item is defined in terms of properties, or fields which hold the actual data. For example, an Item Contact may have a field Name which is a ScalarType, and one field Address, a NestedType, which is further composed of two ScalarTypes. To define this type, the base class Item is extended and the necessary fields are added to the class. A NestedType field can be defined as another class which contains the two ScalarType fields. Once the type is defined, a schema has to be defined, which denotes the primitive type of each field, for example, the Name field is a String, the Address field is a custom defined Address class, both the fields of which are Strings. Other primitive types that WinFS supports are Integer, Byte, Decimal, Float, Double, Boolean and DateTime, among others. The schema will also define which fields are mandatory and which are optional. The Contact Item defined in this way will be used to store information regarding the Contact, by populating the properties field and storing it. Only those fields marked as mandatory needs to be filled up during initial save. Other fields may be populated later by the user, or not populated at all. If more properties fields, such as "last conversed date", needs to be added, this type can be simply extended to accommodate them. Item types for other data can be defined similarly.

Relationships

WinFS creates tables for all defined Items. All the fields defined for the Item form the columns of the table and all instances of the Item are stored as rows in the table for the respective Items. Whenever some field in the table refers to data in some other table, it is considered a relationship. The schema of the relationship specifies which tables are involved and what the kind and name of the relationshp is. The WinFS runtime manages the relationshp schemas. All Items are exposed as .NET CLR objects, with uniform interface providing access to the data stored in the fields. Thus any application can retrieve object of any Item type and can use the data in the object, without being bothered about the physical structure the data was stored in.

WinFS types are exposed as .NET classes, which can be instantiated as .NET objects. Data is stored in these type instances by setting their properties. Once done, they are persisted into the WinFS store. An WinFS store is accessed using an ItemContext class (see Data retrieval section for details). ItemContext allows transactional access to the WinFS store, i.e., all the operations since binding an ItemContext object to a store till it is closed either all succeeds or all changes are rolled back. As the changes are made to the data, they are nor written to the disc; rather they are written to a in-memory log. Only when the connection is closed are the changes written to the disc in a batch. This helps optimize disc I/O. The following code snippet creates a contact and stores in a WinFS store.

 //Connect to the default WinFS store
 using(ItemContext ic = ItemContext.Open())
 {
     //Create the contact and set the data in appropriate properties
     ContactEAddress contact = new ContactEAddress();

     //Name is a ComplexType
     contact.Name = new PersonName();                  
         contact.Name.Displayname = "Doe, John";
         contact.Name.FirstName = "John";
         contact.Name.LastName = "Doe";

     //Telephone number is a ComplexType
     contact.TelephoneNumber = new TelephoneNumber();  //ComplexType
         contact.TelephoneNumber.Country = CountryCode.Antarctica;
         contact.TelephoneNumber.Areacode = 4567;
         contact.TelephoneNumber.Number = 9876543210;

     //Age is a SimpleType
     contact.Age = 111;

    //Add the object to the user's personal folder.
    //This relates the item with the Folder pseudo-type, for backward
    //compatibility, as this lets the item to be accessed in a folder 
    //hierarchy for apps which are not WinFS native.
    Folder containingFolder = UserDataFolder.FindMyPersonalFolder();
    containingFolder.OutFolderMemberRelationship.AddItem(ic, contact);

    //Find a document and relate with the document. Searching begins by creating an
    //ItemSearcher object. Each WinFS type object contains a GetSearcher() method
    //that generates an ItemSearcher object which searches documents of that type.
    using (ItemSearcher searcher = Document.GetSearcher(ic))
    {
         Document d = searcher.Find(@"Title = 'Some Particular Document'");
         d.OutAuthoringRelationship.AddItem(ic, contact);
    }
    //Since only one document is to be found, the ItemContext.FindOne() method
    //could be used as well.

    //Find a picture and relate with it
    using (ItemSearcher searcher = Picture.GetSearcher(ic))
    {
         Picture p = searcher.Find(@"Occasion = 'Graduation' and Sequence = '3'");
         p.OutSubjectRelationship.AddItem(ic, contact);
    }

    //Persist to the store and close the reference to the store
    ic.Update();
    ic.Close();
 }

Relationships

A datum can be related to one more item, giving rise to a one-to-one relationship, or with more than one items, resulting in a one-to-many relationship. The related items, in turn, may be related to other data items as well, resulting in a network of relationships, which is called a many-to-many relationship. Creating a relationship between two Items create another field in the data of the Items concerned which refer the row in the other Item’s table where the related object is stored.

WinFS Relationships

In WinFS, a Relationship is an instance of the base type Relationship, which is extended to signify a specialization of a relation. A Relationship is a mapping between two items, a Source and a Target. The source has an Outgoing Relationship, whereas the target gets an Incoming Relationship. WinFS provides three types of primitive relationships – Holding Relationship, Reference Relationship and Embedding Relationship. Any custom relationship between two data types are instances of these relationship types.

• Holding Relationships specifies ownership and lifetime (which defines how long the relationship is valid) of the Target Item. For example, the Relationship between a folder and a file, and between an Employee and his Salary record, is a Holding Relationship – the latter is to be removed when the former is removed. A Target Item can be a part of more than one Holding Relationships. In such a case, it is to be removed when all the Source Items are removed.
• Reference Relationships provide linkage between two Items, but do not have any lifetime associated, i.e., each Item will continue to be stored even without the other.
• Embedding Relationships give order to the two Items which are linked by the Relationship, such as the Relationship between a Parent Item and a Child Item.

Relationships between two Items can either be set programmatically by the application creating the data, or the user can use the WinFS Item Browser to manually relate the Items. A WinFS item browser can also graphically display the items and how they are related, to enable the user to know how their data are organized.

Rules

WinFS includes Rules, which are executed when certain condition is met. WinFS rules work on data and data relationships. For example, a rule can be created which states that whenever an Item is created which contains field "Name" and if the value of that field is some particular name, a relationship should be created which relates the Item with some other Item. WinFS rules can also access any external application. For example, a rule can be built which launches a Notify application whenever a mail is received from a particular contact. WinFS rules can also be used to add new properties fields to existing data Items.

WinFS rules are also exposed as .NET CLR objects. As such any rule can be used for any purpose. A rule can even be extended by inheriting from it to form a new rule which consists of the condition and action of the parent rule plus something more.

RAV

WinFS supports creating Rich Application Views (RAV) by aggregating different data in a virtual table format. Unlike database view, where each individual element can only be a scalar value, RAVs can have complex Items or even collection of Items. The actual data can be across multiple data types or instances and can even be retrieved by traversing relationships. RAVs are intrinsically paged (dividing the entire set of data into smaller pages containing disconnected subsets of the data) by the WinFS runtime. The page size is defined during creation of the view and the WinFS API exposes methods to iterate over the pages. RAVs also supports modification of the view according to different grouping parameters. Views can also be queried against.

Access control

Even though all data is shared, everything is not equally accessible. WinFS uses Windows authentication system to provide two data protection mechanisms. First, there is share-level security that controls access to your WinFS share. Second, there is item level security that supports NT compatible security descriptors. The process accessing the item must have enough privileges to access it. Also in Vista there is the concept of "integrity level" for an application. A higher integrity data cannot be accessed by a lower integrity process.

Data retrieval

Flowchart for creating, searching and updating WinFS data instances.

The primary mode of data retrieval from a WinFS store is querying the WinFS store according to some criteria, which returns an enumerable set of items matching the criteria. The criteria for the query is specified using the OPath query language. The returned data is made available as instances of the type schemas, conforming to the .NET object model. The data in them can be accessed by accessing the properties of individual objects.

Relations are also exposed as properties. Each WinFS Item has two properties, named IncomingRelationships and OutgoingRelationships, which provides access to the set of relationship instances the item participates in. The other item which participates in one relationship instance can be reached through the proper relationship instance.

The fact that the data can be accessed using its description, rather than location, can be used to provide end-user organizational capabilities without limiting to the hierarchical organization as used in file-systems. In a file system, each file or folder is contained in only one folder. But WinFS Items can participate in any number of holding relationships, that too with any other items. As such, end users are not limited to only file/folder organization. Rather, a contact can become a container for documents; a picture a container for contacts and so on. For legacy compatibility, WinFS includes a pseudo-type called Folder which is present only to participate in holding relationships and emulate file/folder organization. Since any WinFS Item can be related with more than one Folder item, from an end user perspective, an item can reside in multiple folders without duplicating the actual data. Applications can also analyze the relationship graphs to present various filters. For example, an email application can analyze the related contacts and the relationships of the contacts with restaurant bills and dynamically generate filters like "Emails sent to people I had lunch with".

Searches

The WinFS API provides a class called the ItemContext class, which is bound to a WinFS store. The ItemContext object can be used to scope the search to the entire store or a subset of it. It also provides transactional access to the store. An object of this class can then spawn an ItemSearcher object which then takes the type (an object representing the type) of the item to be retrieved or the relationship and the OPath query string representing the criteria for the search. A set of all matches are returned, which can then be bound to an UI widget for displaying en masse or enumerating individually. The properties items can also be modified and then stored back to the data store to update the data. The ItemContext object is closed (which marks the end of association of the object with the store) when the queries are made or changes merged into the store.

Related items can also be accessed through the items. The IncomingRelationships and OutgoingRelationships properties gives access to all the set of relationship instances, typed to the name of the relationship. These relationship objects expose the other item via a property. So, for example, if a picture is related to a picture, it can be accessed by traversing the relationship as:

 ContactsCollection contacts = picture.OutgoingRelationships.Cast(typeof(Contact)).Value;
 //This retrieves the collection of all outgoing relationships from a picture object
 //and filters down the contacts reachable from them and retrieves its value.

 //Or the relationship can be statically specified as
 ContactsCollection contacts = picture.OutgoingRelationships.OutContactRelationship.Contact;

An OPath query string allows to express the parameters that will be queried for to be specified using Item properties, embedded Items as well as Relationships. It can specify a single search condition, such as "title = Something'", or a compound condition such as "title = 'Title 1' || title = 'Title 2' && author = 'Someone'". These boolean and relational operations can be specified using C# like &&, ||, =, != operators as well as their English-like equivalent like EQUAL, NOT EQUAL. SQL like operators such as LIKE, GROUP BY and ORDER BY are also supported, as is wildcard conditions. So, "title LIKE 'any*'" is a valid query string. These operators can be used to execute complex searches such as

 using ( ItemContext ic = ItemContext.Open() )
 {
     //Searching begins by creating a ItemSearcher object. The searcher is created from a
     //relationship instance because the contacts being searched for are in relation. The
     //first parameter defines the scope of the search. An ItemContext as the scope means
     //the entire store is to be searched. Scope can be limited to a set of Items which may
     //be in a holding relationship with the contacts. In that case, the set is passed as
     //the scope of the search.
     ItemSearcher searcher = OutContactRelationship.GetTargetSearcher(ic, typeof(Contact));
     ContactCollection contacts = searcher.FindAll("OutContactRelationship.Contact.Name LIKE 'A*'");
     ic.Close();
 }

The above code snippet creates an ItemSearcher object that searchs on the OutContactRelationship instance that relates pictures and contacts, in effect searching all pictures related with a contact. It then runs the query Name LIKE 'A*'" on all contacts reachable through OutContactRelationship, returning the list of "contacts whose names start with A and whose pictures I have. Similarly more relationships could be taken into account to further narrow down the results. Further, a natural language query processor, which parses query in natural language and creates a well-formed OPath query string to search via proper relationships, can allow users to make searches such as "find the name of the wine I had with person X last month", provided financial management applications are using WinFS to store bills.

Different relations specify a different set of data. So when a search is made which encompasses multiple relations, the different sets of data are retrieved individually and a union of the different sets is computed. The resulting set contains only those data items which correspond to all the relations.

Notifications

WinFS also includes better support for handling data that changes frequently. Using WinFS Notifications, applications choose to be notified of changes to selected data Items. WinFS will raise an ItemChangedEvent, using the .NET Event model, when a subscribed-to Item changes, and the event will be published to the applications.

Data sharing

WinFS allows easy sharing of data between applications, and among multiple WinFS stores, which may reside on different computers, by copying to and from them. A WinFS item can also be copied to a non-WinFS file system, but unless that data item is put back into the WinFS store, it will not support the advanced services provided by WinFS.

The WinFS API also provides some support for sharing with non-WinFS applications. WinFS exposes a shell object to access WinFS stores. This object maps WinFS items to a virtual folder hierarchy, and can be accessed by any application. WinFS data can also be manually shared using network shares, by sharing the legacy shell object. Non-WinFS file formats can be stored in WinFS stores, using the File Item, provided by WinFS. Importers can be written, to convert specific file formats to WinFS Item types.

In addition, WinFS provides services to automatically synchronize items in two or more WinFS stores, subject to some predefined condition, such as "share only photos" or "share photos which have an associated contact X". The stores may be on different computers. Synchronization is done in a peer-to-peer fashion; there is no central authority. A synchronization can be either manual or automatic or scheduled. During synchronization, WinFS finds the new and modified Items, and updates accordingly. If two or more changes conflict, WinFS can either resort to automatic resolution based on predefined rules, or defer the synchronization for manual resolution. WinFS also updates the schemas, if required.

Application support

Shell namespace

WinFS Beta 1 includes a shell namespace extension, which surfaces WinFS stores as top level objects in My Computer view. Files can be copied into and out of the stores, as well as applications can be directly used to save there. Even folders such as My Documents can be redirected to the stores. WinFS uses Importer plug-ins to analyze the files as they were being imported to the store and create proper WinFS schemas and objects, and when taking the objects out, re-pack them into files. If importers for certain files are not installed, they are stored as generic File types.

Microsoft Rave

Microsoft Rave is an application that shipped with WinFS Beta 1. It allows synchronization of two or more WinFS stores. It supports synchronization in full mesh mode as well as the central hub topology. While synchronizing, Microsoft Rave will determine the changes made to each store since the last sync, and update accordingly. When applying the changes, it also detects if there is any conflict, i.e., the same data has been changed on both stores since the last synchronization. It will either log the conflicting data for later resolution or have it resolved immediately. Microsoft Rave uses peer-to-peer technology to communicate and transfer data.

StoreSpy

File:Storespy.jpg

WinFS included StoreSpy, an WinFS Item browser that could be used to browse structured data instances with their properties and relationships.

With WinFS Beta 1, Microsoft included an unsupported application called StoreSpy, which allowed one to browse WinFS stores by presenting a hierarchical view of WinFS Items. It automatically generated virtual folders based on access permissions, date and other metadata, and presented them in a hierarchical tree view, akin to what traditional folders are presented in. The application generated tabs for different Item types. StoreSpy allowed viewing Items, Relationships, MultiSet, Nested Elements, Extensions and other types in the store along with its full metadata. It also presented a search interface to perform manual searches, and save them as virtual folders. The application also presented a graphical view of WinFS Rules. However, it did not allow editing of Items or their properties, though it was slated for inclusion in a future release. But the WinFS project was cut back before it could materialize.

瀏覽類型

WinFS also includes another application, named WinFS Type Browser, which can be used to browse the WinFS types, as well as visualize the hierarchical relationship between WinFS types. A WinFS type, both built-in types as well as custom schemas, can be visualized along with all the properties and methods that it supports. It also shows the types that it derives from as well as other types that extend the type schema. However, while it was included with WinFS, it was released as an unsupported tool.

OPather

WinFS Beta 1 also includes an unsupported application, named OPather. It presents a graphical interface for writing Opath queries. It can be used by selecting target object type and specifying the parameters of the query. It also includes Intellisense-like parameter completion feature. It can then be used to perform visualization tasks like binding results of a query to a DataGrid control, create views of the data in WinFS itself, or just extract the query string.

"Orange" 項目

Microsoft launched a project to build a data visualization application for WinFS. It was codenamed "Project Orange" and was supposedly built using Windows Presentation Foundation. It was supposed to provide exploration of Items stored in WinFS stores, and data relationships were supposed to be a prominent part of the navigation model. It was supposed to let people allow organization of the WinFS stores graphically as well - productizing many of the concepts shown in the IWish Concept Video. However, since the WinFS project went dark, the status of this project is unknown.

See also

• Desktop organizer
• Relational Database Management System
• Storage, a storage management system for GNOME desktop
• NEPOMUK-KDE

外部連結

• WinFS Blog
• WinFS at the Microsoft Developer Network
• Channel 9 Videos
• WinFS Newsgroup
• WinFS Beta 1 Review
• WinFS area on NetFXGuide.com