Felhasználó által definiált adattípusok a Bicepben

  • Cikk

Megtudhatja, hogyan használhat felhasználó által definiált adattípusokat a Bicepben.

A funkció használatához a Bicep CLI 0.12.X vagy újabb verziója szükséges.

Felhasználó által definiált adattípus szintaxisa

Az type utasítás használatával definiálhat felhasználó által definiált adattípusokat. Emellett egyes helyeken típuskifejezéseket is használhat egyéni típusok definiálásához.

type <user-defined-data-type-name> = <type-expression>

Megjegyzés:

A @allowed dekoratőr csak a nyilatkozatokban paramengedélyezett. Ha azt szeretné deklarálni, hogy egy tulajdonságnak egy vagy output utasításban előre definiált értékek type egyikének kell lennie, használja az egyesítő típusú szintaxist. Az egyesítő típusú szintaxis az utasításokban paramis használható.

Az érvényes típuskifejezések a következők:

  • A szimbolikus hivatkozások olyan azonosítók, amelyek környezeti típusra (például string vagy int) vagy egy utasításban deklarált felhasználó által definiált típusszimbólumra type hivatkoznak:

    // Bicep data type reference
type myStringType = string

// user-defined type reference
type myOtherStringType = myStringType

  • A primitív literálok, beleértve a sztringeket, az egész számokat és a logikai értékeket, érvényes típuskifejezések. Például:

    // a string type with three allowed values.
type myStringLiteralType = 'bicep' | 'arm' | 'azure'

// an integer type with one allowed value
type myIntLiteralType = 10

// an boolean type with one allowed value
type myBoolLiteralType = true

  • A tömbtípusok bármely érvényes típuskifejezés utótagjával [] deklarálhatók:

    // A string type array
type myStrStringsType1 = string[]
// A string type array with three allowed values
type myStrStringsType2 = ('a' | 'b' | 'c')[]

type myIntArrayOfArraysType = int[][]

// A mixed-type array with four allowed values
type myMixedTypeArrayType = ('fizz' | 42 | {an: 'object'} | null)[]

  • Az objektumtípusok nulla vagy több tulajdonságot tartalmaznak a kapcsos zárójelek között:

    type storageAccountConfigType = {
  name: string
  sku: string
}

    Egy objektum minden tulajdonsága kulcsból és értékből áll. A kulcsot és az értéket kettőspont :választja el egymástól. A kulcs lehet bármilyen sztring (az érvényes azonosítót nem tartalmazó értékeket idézőjelek közé kell tenni), az érték pedig bármilyen típusú szintaxiskifejezés lehet.

    A tulajdonságok csak akkor szükségesek, ha a tulajdonság értéke után választhatósági jelölővel ? rendelkeznek. A következő példában szereplő tulajdonság például sku nem kötelező:

    type storageAccountConfigType = {
  name: string
  sku: string?
}

    Dekorátorok használhatók a tulajdonságokon. * használható arra, hogy az összes érték kényszert igényeljen. A további tulajdonságok továbbra is meghatározhatók a használat *során. Ez a példa létrehoz egy objektumot, amely egy int nevű idtípuskulcsot igényel, és hogy az objektum többi bejegyzésének legalább 10 karakter hosszúságú sztringértéknek kell lennie.

    type obj = {
  @description('The object ID')
  id: int

  @description('Additional properties')
  @minLength(10)
  *: string
}

    Az alábbi minta bemutatja, hogyan használható az egyesítő típusú szintaxis az előre definiált értékek listájára:

    type obj = {
  level: 'bronze' | 'silver' | 'gold'
}

    Rekurzió

    Az objektumtípusok közvetlen vagy közvetett rekurziót használhatnak mindaddig, amíg a rekurziós pont elérési útjának legalább a lába nem kötelező. A következő példában szereplő definíció például érvényes, myObjectType mert a közvetlenül rekurzív recursiveProp tulajdonság nem kötelező:

    type myObjectType = {
  stringProp: string
  recursiveProp: myObjectType?
}

    A következő típusdefiníció azonban nem lenne érvényes, mert egyik semlevel1, level3level2level4vagy level5 nem kötelező.

    type invalidRecursiveObjectType = {
  level1: {
    level2: {
      level3: {
        level4: {
          level5: invalidRecursiveObjectType
        }
      }
    }
  }
}

  • A Bicep nem szereplő operátorok egész számokkal és logikai literálokkal, illetve egész számra vagy logikai literál típusú szimbólumokra mutató hivatkozásokkal használhatók:

    type negativeIntLiteral = -10
type negatedIntReference = -negativeIntLiteral

type negatedBoolLiteral = !true
type negatedBoolReference = !negatedBoolLiteral

  • Az egyesítők tetszőleges számú literál típusú kifejezést tartalmazhatnak. Az egyesítő típusok a Bicep megengedett értékkorlátjába vannak lefordítva, így tagokként csak a literálok engedélyezettek.

    type oneOfSeveralObjects = {foo: 'bar'} | {fizz: 'buzz'} | {snap: 'crackle'}
type mixedTypeArray = ('fizz' | 42 | {an: 'object'} | null)[]

Az utasításban type való használat mellett típuskifejezések is használhatók ezeken a helyeken a felhasználó által definiált adattípusok létrehozásához:

  • Egy utasítás típuskikötéseként param . Például:

    param storageAccountConfig {
  name: string
  sku: string
}

  • : Az objektumtípus tulajdonságot követve. Például:

    param storageAccountConfig {
 name: string
  properties: {
    sku: string
  }
} = {
  name: 'store$(uniqueString(resourceGroup().id)))'
  properties: {
    sku: 'Standard_LRS'
  }
}

  • [] A tömbtípus-kifejezés előtt. Például:

    param mixedTypeArray ('fizz' | 42 | {an: 'object'} | null)[]

Egy tárfiók létrehozásához használt tipikus Bicep-fájl a következőképpen néz ki:

param location string = resourceGroup().location
param storageAccountName string

@allowed([
  'Standard_LRS'
  'Standard_GRS'
])
param storageAccountSKU string = 'Standard_LRS'

resource storageAccount 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: storageAccountSKU
  }
  kind: 'StorageV2'
}

Felhasználó által definiált adattípusok használatával a következőképpen nézhet ki:

param location string = resourceGroup().location

type storageAccountSkuType = 'Standard_LRS' | 'Standard_GRS'

type storageAccountConfigType = {
  name: string
  sku: storageAccountSkuType
}

param storageAccountConfig storageAccountConfigType

resource storageAccount 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: storageAccountConfig.name
  location: location
  sku: {
    name: storageAccountConfig.sku
  }
  kind: 'StorageV2'
}

Címkézett egyesítő típus deklarálása

Ha egyéni címkézett egyesítő adattípust szeretne deklarálni egy Bicep-fájlban, a felhasználó által meghatározott típusú deklarálás fölé helyezhet egy diszkriminatív deklarátort. A dekorátor használatához a Bicep CLI 0.21.X-es vagy újabb verziója szükséges. A szintaxis a következő:

@discriminator('<propertyName>')

A diszkriminatív dekorátor egyetlen paramétert vesz fel, amely az összes szakszervezeti tag közös tulajdonnevét jelöli. Ennek a tulajdonságnévnek kötelező sztringkonstansnak kell lennie az összes tagon, és megkülönbözteti a kis- és nagybetűk megkülönböztetése. A szakszervezeti tagok hátrányos megkülönböztetett tulajdonságának értékeinek egyedinek kell lenniük kis- és nagybetűket nem megkülönböztető módon.

Az alábbi példa bemutatja, hogyan deklarálhat címkézett egyesítő típust:

type FooConfig = {
  type: 'foo'
  value: int
}

type BarConfig = {
  type: 'bar'
  value: bool
}

@discriminator('type')
type ServiceConfig = FooConfig | BarConfig | { type: 'baz', *: string }

param serviceConfig ServiceConfig = { type: 'bar', value: true }

output config object = serviceConfig

A paraméter értéke a megkülönböztető tulajdonság értéke alapján lesz érvényesítve. Az előző példában, ha a serviceConfig paraméter értéke foo típusú, akkor a FooConfigtípus használatával végez ellenőrzést. Hasonlóképpen, ha a paraméter értéke típussáv, az érvényesítés a BarConfig típussal történik, és ez a minta más típusok esetében is folytatódik.

Típusok importálása Bicep-fájlok között (előzetes verzió)

A bicep CLI 0.21.X vagy újabb verziója szükséges a fordítási idő importálási funkció használatához. A kísérleti jelzőt compileTimeImports engedélyezni kell a Bicep konfigurációs fájlból.

Más sablonokba csak a @export() dekoratőrt tartalmazó felhasználó által definiált adattípusok importálhatók. Ez a dekorátor jelenleg csak utasításokban type használható.

Az alábbi példa lehetővé teszi a két felhasználó által definiált adattípus importálását más sablonokból:

@export()
type myStringType = string

@export()
type myOtherStringType = myStringType

További információ: Felhasználó által definiált adattípusok importálása.

További lépések