mappage de type

Article
05/17/2015

Le mappage de type est le processus par lequel les types d'objets de données définis par les fournisseurs de données sont mappés aux types de données génériques définis par le moteur de métadonnées de Visual Studio.

Le problème de mappage spécifique à la source de données aux concepts génériques (« b : gmappant le problème ») se produit lorsque vous avez des types d'objets qui sont des types d'autres types, comme, par exemple, lorsqu'une clé unique est un genre de contrainte, ou une clé primaire est un genre de clé unique. Par conséquent, un type spécifique à la source de données peut ou être généralisé (par exemple, Constraint) ou plus précis (comme PrimaryKey, UniqueKey, ou ForeignKey). Si les concepts génériques sont de façon équivalente non globalisés ou précis, vous rencontrez la BG mappant le problème.

le mappage de type se produit dans quatre versions :

mappage de type de 1:1
1 : mappage de type de g
b : 1 Mappage de type
b : mappage de type de g

Les sections suivantes traitent chacun des cas après.

mappage de type de 1:1

Un mappage un-à-un est le cas le plus simple et se produit lorsqu'un fournisseur de données a un type spécifique à la source de données unique qui mappe à un seul type mappé par générique. vous pouvez appliquer un mappage univoque de ce type en spécifiant l'attribut d'underlyingType dans l'élément de MappedType, qui mappe le type mappé par générique (élément XML de MappedType) au type spécifique à la source de données (élément XML de type). Ceci est illustré dans l'exemple XML suivant :

Le code XML suivant du fichier XML de DataObjectSupport illustre la déclaration spécifique à la source de données de colonne :

<Type name="Column" preferredOrdering="Database, Schema, Table, Id">
    <IdentifierRef name="SubSchemaObjectTypeIdentifier" arguments="Table" />
    <Properties>
        <PropertyListRef name="ColumnProperties" />
        <Property name="Computed" type="System.Boolean" />
    </Properties>
    <Services>
        <ServiceRef name="SubSchemaObjectTypeObjectSelectorService" arguments="Table, Table, Column, ColumnSelectorMappings" />
        <ServiceRef name="SubSchemaObjectTypeDSRefBuilderService" arguments="Table, 101, Field, 102" />
    </Services>
</Type>

Le code XML suivant du fichier XML de DataObjectSupport illustre la déclaration du type mappé par générique de TableColumn mappé vers le type de colonne ci-dessus via l'attribut d'underlyingType :

<MappedType name="TableColumn" underlyingType="Column">
    <Selection restrictions="{Catalog},{Schema},{Table},{Name}" />
    <IdentifierRef name="MappedSubTypeIdentifier" arguments="Table" />
    <Properties>
        <Property name="Name" isIdentifierPart="true" />
        <Property name="Ordinal" underlyingMember="Id" />
        <PropertyListRef name="MappedSubTypeDataTypeProperties" />
        <Property name="IsNullable" underlyingMember="Nullable" />
        <Property name="IsComputed" underlyingMember="Computed" />
    </Properties>
</MappedType>

pour étendre l'exemple, considérez l'architecture des contraintes uniques dans SQL Server. Pour chaque contrainte unique il existe toujours un index, et toutes les métadonnées pour exposer des contraintes uniques sont fournies par l'intermédiaire de son index. Il peut lire, puis, qu'une seule clé est un genre d'index dans SQL Server. Dans les cas où un concept générique, index, prend en charge l'idée qu'il peut également être une clé unique, le mappage est 1:1 et est géré facilement.

1 : g tapez le mappage

Le cas de mapper un type spécifique à la source de données à un type mappé par générique est quelque peu plus complexe. Pour illustrer, considérez l'exemple ci-dessus (pour le mappage 1:1, qui est). Dans ce cas, toutefois, le type mappé par générique est UniqueKey; cela provoque un 1 :g mappant, où un type spécifique à la source de données unique (index) représente le type mappé plusieurs par générique ( UniqueKey et Index). Un fournisseur de données doit désormais mapper les types mappés par plusieurs à un type d'objet, comme dans l'exemple suivant :

<MappedType name="TableUniqueKey" underlyingType="Index">
    <Selection restrictions="{Catalog},{Schema},{Table},{Name}" filter="KeyType > 0" />
    <IdentifierRef name="MappedSubTypeIdentifier" arguments="Table" />
    <Properties>
        <Property name="Name" isIdentifierPart="true" />
        <Property name="IsPrimary" underlyingMember="KeyType">
            <Conversion>
                <Calculate expr="IIF({0} = 1, true, false)" exprType="System.Boolean" />
            </Conversion>
        </Property>
    </Properties>
</MappedType>
<MappedType name="Index" underlyingType="Index">
    <Selection restrictions="{Catalog},{Schema},{Table},{Name}" />
</MappedType>

Notez l'attribut d' filter spécifié sur le concept d' UniqueKey . Il s'agit de la meilleure façon d'identifier le sous-ensemble d'instances du type spécifique à la source de données qui représente en réalité ce concept générique.

b : 1 Mappage de type

La casse types spécifiques à la source de données d'un mappage de fournisseur de données de plusieurs à un type mappé par générique unique requiert spécifier un type mappé unique sur plusieurs types sous-jacents. Par exemple, supposons que le fournisseur de données définit les types spécifiques à la source de données UniqueKey et ForeignKey, qui sont des types de contraintes. Ensuite, supposez qu'il existe un type mappé par générique, Constraint, qui entoure tous les types de contrainte. le résultat est b: 1 mappage-qu'est, plusieurs types spécifiques à la source de données représentés par un générique unique pour mapper le type.

Activant ce cas requiert un peu plus de XML qui ont fait les cas précédents, comme dans l'exemple suivant :

<Type name="ForeignKey" preferredOrdering="Database, Schema, Table, Name">
…
</Type>
<Type name="UniqueKey" preferredOrdering="Database, Schema, Table, Name">
…
</Type>
<MappedType name="Constraint" underlyingType="ForeignKey">
…
</MappedType>
<MappedType name="Constraint" underlyingType="UniqueKey">
…
</MappedType>

b : g tapez le mappage

Enfin, la casse de plusieurs types spécifiques à la source de données de mappage à plusieurs concepts génériques est une combinaison de 1 :g et b: mappages 1. Par exemple, supposons qu'un fournisseur de données spécifique à la source de données sépare les concepts d'une clé primaire d'autres contraintes (par exemple, de la clé unique et de la clé étrangère). Dans ce cas il peut y avoir des types spécifiques à la source de données PrimaryKey et Constraint. Maintenant, supposez qu'il existe des concepts génériques UniqueKey et ForeignKey, où le concept d' UniqueKey entoure primaire et des clés uniques. C'est b : g mappant, dans lequel plusieurs types spécifiques à la source de données sont représentés par les types mappés plusieurs par générique.

Pour gérer ce cas, le fournisseur de données applique ce mappage en spécifiant les types mappés par plusieurs sur plusieurs types spécifiques à la source de données, comme illustré dans le code XML suivant :

<Type name="PrimaryKey" preferredOrdering="Database, Schema, Table, Name">
…
</Type>
<Type name="Constraint" preferredOrdering="Database, Schema, Table, Name">
…
</Type>
<MappedType name="UniqueKey" underlyingType="PrimaryKey">
…
</MappedType>
<MappedType name="UniqueKey" underlyingType="Constraint">
    <Selection restrictions="{Catalog},{Schema},{Table},{Name}" filter="IsUnique = true" />
</MappedType>
<MappedType name="ForeignKey" underlyingType="Constraint">
    <Selection restrictions="{Catalog},{Schema},{Table},{Name}" filter="IsForeign = true" />
</MappedType>

Voir aussi

Concepts

identificateur et mappage de propriété

identificateurs de type et propriétés d'objet de mappage aux types génériques

Partager via