GlobalItem Klasse

Definition

Namespace:

System.Data.Metadata.Edm

Assembly:

System.Data.Entity.dll

Stellt die Basiselementklasse für alle konzeptionellen Modelltypen und Entitätscontainer dar.

public ref class GlobalItem abstract : System::Data::Metadata::Edm::MetadataItem

public abstract class GlobalItem : System.Data.Metadata.Edm.MetadataItem

type GlobalItem = class
    inherit MetadataItem

Public MustInherit Class GlobalItem
Inherits MetadataItem

Vererbung

Object

MetadataItem

GlobalItem

Abgeleitet

System.Data.Metadata.Edm.EdmType

System.Data.Metadata.Edm.EntityContainer

Beispiele

Im folgenden Codebeispiel wird dargestellt, wie von der Verbindung ein Metadaten-Arbeitsbereich abgerufen und verwendet wird, um die Metadatentyp-Hierarchie zu durchsuchen. Beachten Sie, dass es sich beim Metadaten-Arbeitsbereich um eine Laufzeitdienstkomponente handelt, die Unterstützung für das Abrufen von Metadaten bereitstellt.

Im Codebeispiel wird CSpace verwendet, um das Modell anzugeben. CSpace stellt den Standardnamen für das konzeptionelle Modell dar. Im Codebeispiel wird die in der Anwendungskonfigurationsdatei bereitgestellte Verbindungszeichenfolge verwendet.

using System;  
using System.Data;  
using System.Data.EntityClient;  
using System.Data.Metadata.Edm;  
using System.Collections.ObjectModel;  

class BrowseTypes  
{  
  static void Main()  
  {  
    try  
    {  
      // Establish a connection to the underlying data provider by  
      // using the connection string specified in the config file.  
      using (EntityConnection connection =  
             new EntityConnection("Name=AdventureworksContext"))  
      {  
         // Access the metadata workspace.  
         MetadataWorkspace workspace =   
              connection.GetMetadataWorkspace();  
         // Browse the metadata type hierarchy.  
         BrowseTypesExample(workspace);  
      }  
    }  
    catch (MetadataException exceptionMetadata)  
    {  
       Console.WriteLine("MetadataException: {0}",  
                         exceptionMetadata.Message);  
     }  
     catch (System.Data.MappingException exceptionMapping)  
     {  
        Console.WriteLine("MappingException: {0}",  
                          exceptionMapping.Message);  
     }  
  }  

  private static void BrowseTypesExample(MetadataWorkspace workspace)  
  {  
    // Get a collection of the GlobalItems.   
    // An GlobalItem class is the base class for   
    // the conceptual model types and entity containers.  
    ReadOnlyCollection<GlobalItem> items =   
         workspace.GetItems<GlobalItem>(DataSpace.CSpace);  

    // Iterate through the collection to get each item.  
    foreach (GlobalItem item in items)  
    {  
       Console.WriteLine(  
           "Item BuiltInTypeKind: {0}, Type: {1} ",   
           item.BuiltInTypeKind, item.GetType().FullName);  

       EntityContainer entityContainer = item as EntityContainer;  
       if (entityContainer != null)  
       {  
          Console.WriteLine(  
               "EntityContainer Name: {0}",  
               entityContainer.Name);  
          continue;  
       }  

       EntityType entityType = item as EntityType;  
       if (entityType != null)  
       {  
         Console.WriteLine(  
             "EntityType Name: {0}, Namespace: {1}",  
             entityType.Name, entityType.NamespaceName);  
        continue;  
       }  

       AssociationType associationType = item as AssociationType;  
       if (associationType != null)  
       {  
          Console.WriteLine(  
             "AssociationType Name: {0}, Namespace: {1}",  
             associationType.Name, associationType.NamespaceName);  
          continue;  
       }  

       PrimitiveType primType = item as PrimitiveType;  
       if (primType != null)  
       {  
         Console.WriteLine(  
             "PrimitiveType Name: {0}, Namespace: {1}",   
             primType.Name, primType.NamespaceName);  
         continue;  
       }  

       EdmFunction function = item as EdmFunction;  
       if (function != null)  
       {  
         Console.WriteLine(  
           "EdmFunction Name: {0}, Namespace: {1}",  
           function.Name, function.NamespaceName);  
         continue;  
       }  
    }  
  }  
}  

Eigenschaften

BuiltInTypeKind	Ruft die integrierte Typart für diesen Typ ab. (Geerbt von MetadataItem)
Documentation	Ruft die diesem Typ zugeordnete Dokumentation ab bzw. legt sie fest. (Geerbt von MetadataItem)
MetadataProperties	Ruft eine Liste der Eigenschaften des aktuellen Typs ab. (Geerbt von MetadataItem)

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)