---
title: "Creat na cineálacha ábhair"
version: 5.2
locale: ga
source: https://docs.djangoproject.com/ga/5.2/ref/contrib/contenttypes/
canonical: https://djangodocs.dev/ga/5.2/ref/contrib/contenttypes/
---
# Creat na cineálacha ábhair

Cuimsíonn Django feidhmchlár a:mod: ~django.contrib.contenttypes atá in ann na samhlacha go léir atá suiteáilte i do thionscadal Django faoi thiomáint a rianú, ag soláthar comhéadan cineálach ardleibhéil chun oibriú le do mhúnlaí.

## Forbhreathnú

I gcroílár an fheidhmchláir contenttypes tá an tsamhail:class: ~django.contrib.contentTypes.Models.contentType, a chónaíonn ag `Django.Contrib.ContentTypes.Models.ContentType`. Léiríonn agus stóráil cásanna de:class: ~django.contrib.contentTypes.Models.ContentType faisnéis faoi na samhlacha atá suiteáilte i do thionscadal, agus cruthaítear cásanna nua de:class: ~Django.Contrib.ContentTypes.Models.ContentType go huathoibríoch aon uair a shuiteáiltear samhlacha nua.

Tá modhanna ag cásanna de:class: ~django.contrib.contentTypes.Models.ContentType chun na ranganna samhail a léiríonn siad a thabhairt ar ais agus chun rudaí a fhiosrú ó na samhlacha sin. :class: ~django.contrib.contentTypes.Models.contentType tá a:ref: bainisteoir saincheapaithe freisin a chuireann modhanna chun oibriú le:class: ~django.contrib.contentTypes.Models.contentType agus chun cásanna de:class: ~django.contrib.contentTypes.Models.contentType \<custom-managers\>\`a fháil do mhúnla áirithe.

Is féidir caidreamh idir do mhúnlaí agus:class: ~django.contrib.contentTypes.Models.contentType a úsáid freisin chun caidrimh “cineálacha” a chumasú idir sampla de cheann de do mhúnlaí agus cásanna d'aon mhúnla atá suiteáilte agat.

## Creat na cineálacha ábhair a shuiteáil

Tá an creat cineálacha ábhair san áireamh sa liosta réamhshocraithe:setting: INSTALLED\_APPS a chruthaigh `django-admin startproject`, ach má bhain tú é nó má shocraigh tú do liosta:setting: INSTALLED\_APPS de láimh, is féidir leat é a chumasú trí `django.contrib.contenttypes'` a chur le d':setting: INSTALLED\_APPS socrú.

De ghnáth is smaoineamh maith é creat na cineálacha ábhair a shuiteáil; éilíonn roinnt d'fheidhmchláir cuabháilte eile Django é:

- Úsáideann an feidhmchlár riaracháin é chun stair gach réad a cuireadh leis nó a athraigh tríd an gcomhéadan riaracháin a logáil.
- Django's:mod: Úsáideann creat fíordheimhniúcháin \<django.contrib.auth\>\`é chun ceadanna úsáideora a cheangal le samhlacha ar leith.

## An tsamhail `ContentType`

#### `class ContentType`

Tá dhá réimse ag gach sampla de:class: ~django.contrib.contentTypes.Models.ContentType a chuireann, le chéile, cur síos uathúil ar mhúnla suiteáilte:

#### `app_label`

Ainm an fheidhmchláir tá an tsamhail mar chuid de. Tógtar é seo ó:attr: app\_label tréith an tsamhail, agus ní chuimsíonn sé ach an cuid deireanaí\* de chonair allmhairithe Python an fheidhmchláir; `django.contrib.contenttypes`, mar shampla, éiríonn u:attr: app\_label de contenttypes\`.

#### `model`

Ainm an rang samhail.

Ina theannta sin, tá an maoin seo a leanas ar fáil:

#### `name`

Ainm inléite don duine ar an gcineál ábhair. \<django.db.models.Field.verbose\_name\>Tógtar é seo ón tréith: attr: verbose\_name den tsamhail.

Breathnaímid ar shampla chun a fheiceáil conas a oibríonn sé seo. Má tá an feidhmchlár: mod: ~django.contrib.contenttypes suiteáilte cheana féin, agus ansin cuir:mod: an feidhmchlár láithreáin \`le do shuiteáil: \`SET \<django.contrib.sites\>TING: \`INSTALLED\_APPS agus rith `manage.py migrate` chun é a shuiteáil, suiteálfar an samhail:class: Django.contrib.sites.models.site i do bhunachar sonraí. In éineacht leis cruthófar sampla nua de:class: ~django.contrib.contentTypes.Models.contentType leis na luachanna seo a leanas:

- [`app_label`](#django.contrib.contenttypes.models.ContentType.app_label)
  will be set to `'sites'` (the last part of the Python
  path `django.contrib.sites`).
- [`model`](#django.contrib.contenttypes.models.ContentType.model)
  will be set to `'site'`.

## Modhanna ar chásanna `ContentType`

Tá modhanna ag gach ceann: Class: ~django.contrib.contentTypes.Models.contentType a ligeann duit a fháil ó a:class: ~django.contrib.contentTypes.Models.contentType sampla don tsamhail a léiríonn sé, nó chun rudaí a aisghabháil ón tsamhail sin:

#### `ContentType.get_object_for_this_type(using=None, **kwargs)`

\<django.db.models.query.QuerySet.get\>Glacann sé tacar d'argóintí bail:ref: lookup \<field-lookups-intro\>\`don tsamhail the:class: \`~django.contrib.contentTypes.Models.contentType léiríonn, agus déanaim:meth: a get () cuardach ar an tsamhail sin, ag cur an réad comhfhreagrach ar ais. Is féidir an argóint úsáid a úsáid chun bunachar sonraí difriúil a shonrú ná an ceann réamhshocraithe.

> **Changed in Django 5.1**
>
> Cuireadh an argóint úsáid leis.

#### `ContentType.model_class()`

Tugann sé an rang samhail a léiríonn this:class: ~django.contrib.contentTypes.Models.contentType sampla.

Mar shampla, d'fhéadfaimis breathnú suas ar:class: ~django.contrib.contentTypes.Models.contentType don tsamhail:class: ~django.contrib.auth.models.user:

```pycon
>>> from django.contrib.contenttypes.models import ContentType
>>> user_type = ContentType.objects.get(app_label="auth", model="user")
>>> user_type
<ContentType: user>
```

Agus ansin bain úsáid as chun ceist a dhéanamh le haghaidh áirithe: class: ~django.contrib.auth.models.user, nó chun rochtain a fháil ar an rang samhail `User`:

```pycon
>>> user_type.model_class()
<class 'django.contrib.auth.models.User'>
>>> user_type.get_object_for_this_type(username="Guido")
<User: Guido>
```

Le chéile, cumasaíonn :meth: ~django.contrib.contenttypes.models.contenttype.get\_object\_for\_this\_type agus:meth: ~django.contrib.contenttypes.models.contenttype.model\_class dhá chás úsáide thar a bheith tábhachtach:

1. Ag baint úsáide as na modhanna seo, is féidir leat cód cineálach ardleibhéil a scríobh a dhéanann ceisteanna ar aon mhúnla suiteáilte - in ionad rang samhail amháin a iompórtáil agus a úsáid, is féidir leat cuardach `app_label` agus model \`\`model\` a chur isteach i a:class: ~django.contrib.contenttypes.models.contentType ag rith, agus ansin oibriú leis an rang samhail nó rudaí a aisghabháil uaidh.
2. Is féidir leat samhail eile a cheangal la:class: ~django.contrib.contentTypes.Models.contentType mar bhealach chun cásanna de a cheangal le ranganna samhail áirithe, agus na modhanna seo a úsáid chun rochtain a fháil ar na ranganna samhail sin.

Baineann roinnt de na feidhmchláir cuabháilte Django úsáid as an teicníc deireanach sin. Mar shampla, :class: an córas ceadanna \<django.contrib.auth.models.Permission\>\`i gcreat fíordheimhnithe Django úsáideann samhail a:class: \`~django.contrib.auth.models.permission le eochair eachtrach chuig:class: ~django.contrib.contentTypes.Models.ContentType; is féidir leis an iontráil blog a chur leis” nó “is féidir scéal nuachta a scriosadh”.

### An `ContentTypeManager`

#### `class ContentTypeManager`

[`ContentType`](#django.contrib.contenttypes.models.ContentType) also has a custom
manager, [`ContentTypeManager`](#django.contrib.contenttypes.models.ContentTypeManager),
which adds the following methods:

#### `clear_cache()`

Glanann sé taisce inmheánach a úsáideann: :class: ~django.contrib.contentTypes.Models.ContentType chun súil a choinneáil ar na samhlacha a bhfuil cruthaithe ai:class: ~django.contrib.contentTypes.Models.contentType cásanna. Is dócha nach mbeidh ort an modh seo a ghlaoch ort féin riamh; Glaoifidh Django air go huathoibríoch nuair a bheidh sé ag teastáil.

#### `get_for_id(id)`

Cuardaigh a:class: ~django.contrib.contentTypes.Models.contentType de réir ID. Ós rud é go n-úsáideann an modh seo an taisce roinnte céanna amha:meth: ~django.contrib.contentTypes.Models.contentTypeManager.get\_for\_model, is fearr an modh seo a úsáid thar an ContentType.Objects.get (pk=id) is gnách

#### `get_for_model(model, for_concrete_model=True)`

Tógann sé rang samhail nó sampla de mhúnla, agus filleann sé an sampla:class: ~django.contrib.contentTypes.Models.contentType a léiríonn an tsamhail sin. Ligeann `for_concrete_model=False` an: class: ~django.contrib.contentTypes.Models.contentType de mhúnla seachfhreastalaí a fháil.

#### `get_for_models(*models, for_concrete_models=True)`

Glacann sé líon éagsúil ranganna samhail, agus cuireann sé foclóir ar ais ag mapáil na ranganna samhail chuig na cásanna: class: ~django.contrib.contentTypes.Models.contentType a léiríonn iad. `for_concrete_models=False` ceadaíonn an: class: ~django.contrib.contentTypes.Models.contentType de mhúnlaí seachfhreastalaí a fháil.

#### `get_by_natural_key(app_label, model)`

Filleann sé an sampla:class: ~django.contrib.contentTypes.Models.contentType a aithnítear go uathúil ag an lipéad iarratais agus ainm an tsamhail. \<topics-serialization-natural-keys\>Is é príomhchuspóir an mhodha seo ná: class: ~django.contrib.contentTypes.Models.contentType rudaí le tagairt a thabhairt trí a:ref: eochair nádúrtha le linn dísheerialaithe.

Tá an modh: Meth: ~ContentTypeManager.get\_for\_Model () \`úsáideach go háirithe nuair a fhios agat go gcaithfidh tú oibriú le a:class: \`ContentType ach níl tú ag iarraidh dul chuig an trioblóid meiteashonraí an tsamhail a fháil chun cuardach lá \<django.contrib.contenttypes.models.ContentType\>imhe a dhéanamh:

```pycon
>>> from django.contrib.auth.models import User
>>> ContentType.objects.get_for_model(User)
<ContentType: user>
```

## Caidreamh cineálach

Ag cur eochair eachtrach ó cheann de do mhúnlaí féin chuig: class: ~django.contrib.contentTypes.Models.ContentType is féidir le do mhúnla é féin a cheangal go héifeachtach le rang samhail eile, mar atá i sampla an tsamhail: ~django.contrib.auth.models.permission thuas. Ach is féidir dul céim amháin níos faide agus úsáid:class: ~django.contrib.contentTypes.Models.contentType chun caidrimh fíor-chineálacha (ar a dtugtar “polaimorfach” uaireanta) idir samhlacha a chumasú.

Mar shampla, d'fhéadfaí é a úsáid le haghaidh córas clibeála mar seo:

```
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
from django.db import models

class TaggedItem(models.Model):
    tag = models.SlugField()
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveBigIntegerField()
    content_object = GenericForeignKey("content_type", "object_id")

    def __str__(self):
        return self.tag

    class Meta:
        indexes = [
            models.Index(fields=["content_type", "object_id"]),
        ]
```

Ní féidir le gnáth:class: ~django.db.models.foreignKey ach “pointe” ar mhúnla amháin eile, rud a chiallaíonn má úsáideann an tsamhail `TaggEditem` a:class: ~Django.db.Models.ForeignKey bheadh air samhail amháin agus amháin a roghnú chun clibeanna a stóráil dó. Soláthraíonn an feidhmchlár contenttypes cineál réimse speisialta (GenericForeignKey) a oibríonn timpeall air seo agus a ligeann don chaidreamh a bheith le haon mhúnla:

#### `class GenericForeignKey`

Tá trí chuid ann chun a: class a bhunú: ~django.contrib.contentTypes.Fields.GenericForeignKey:

1. Tabhair do mhúnla a:class: ~django.db.models.foreignKey chuig: class: ~django.contrib.contentTypes.Models.ContentType. Is é “content\_type” an gnáthainm don réimse seo.
2. Give your model a field that can store primary key values from the
   models you'll be relating to. For most models, this means a
   [`PositiveBigIntegerField`](/ga/5.2/ref/models/fields/#django.db.models.PositiveBigIntegerField). The usual name
   for this field is "object\_id".
3. Tabhair do mhúnla a:class: ~django.contrib.contentTypes.Fields.GenericForeignKey, agus cuir ainmneacha an dá réimse a thuairiscítear thuas air. Má ainmnítear na réimsí seo “content\_type” agus “object\_id”, is féidir leat é seo a fhágáil - is iad sin na hainmneacha réimse réamhshocraithe: class: ~django.contrib.contentTypes.fields.GenericForeignKey a lorgfaidh.

\<django.db.models.Options.indexes\>Murab ionann agus don: class: ~django.db.models.foreignKey, cruthaítear innéacs bunachar sonraí *not* go huathoibríoch ar:class: ~django.contrib.contentTypes.Fields.GenericForeignKey, mar sin moltar duit: attr: Meta.Indexes a úsáid chun d'innéacs colún iolrach féin a chur leis. An t-iompar seo: ticéad: d'fhéadfadh athrú \<23435\>\`sa todhchaí.

#### `for_concrete_model`

Má tá `False`, beidh an réimse in ann samhlacha seachfhreastalaí a thagairt. Is é réamhshocraithe `True`. Léiríonn sé seo an argóint `for_concrete_model` chuig: meth: ~django.contrib.contentTypes.Models.contentTypeManager.get\_for\_model.

> **Comhoiriúnacht príomhchineál**
>
> Ní gá go mbeadh an réimse “object\_id” an cineál céanna leis na príomhréimsí ar na samhlacha gaolmhara, ach caithfidh a bpríomh-luachanna a bheith inéigeantach don chineál céanna leis an réimse “object\_id” trí:meth: ~django.db.models.field.get\_db\_prep\_value modh.
>
> Mar shampla, más mian leat caidreamh cineálach a cheadú le samhlacha le príomhréimsí éither:class: ~django.db.models.integerfield nó:class: ~django.db.models.charfield príomhréimsí, is féidir leat:class: ~django.db.models.charfield a úsáid don réimse “object\_id” ar do mhúnla ós rud é gur féidir slána a úsáid chuig teaghráin ag: meth: ~django.db.models.field.get\_db\_prep\_value.
>
> Chun an tsolúbthacht is mó is féidir leat a: class: ~django.db.models.textfield a úsáid nach bhfuil an fad uasta sainmhínithe aige, ach d'fhéadfadh pionóis feidhmíochta suntasacha a bheith air seo ag brath ar do chúltaca bunachar sonraí.
>
> Níl aon réiteach aonmhéid a oireann do gach duine cén cineál réimse is fearr dó. Ba cheart duit meastóireacht a dhéanamh ar na samhlacha a bhfuil tú ag súil leo a bheith ag cur in iúl agus a chinneadh cén réiteach is éifeachtaí do do chás úsáide

> **Tagairtí a shraitheadh do rudaí contentType**
>
> Má tá sonraí á sraitheadh agat (mar shampla, agus tú ag giniú:class: ~django.test.transactionTestCase.fixtures) ó mhúnla a chuireann caidreamh cineálach i bhfeidhm, is dócha go mbeadh eochair nádúrtha á úsáid agat chun rudaí gaolmha:class: ~Django.Contrib.ContentTypes.Models.ContentType a aithint go uathúil. Féach: ref: eochracha nádúrtha \`agus \<topics-serialization-natural-keys\>:option: \`dumpdata --natural-foreign le haghaidh tuilleadh faisnéise.

Cuirfidh sé seo ar chumas API cosúil leis an gceann a úsáidtear le haghaidh gnáth:class: ~django.db.models.foreignKey; beidh réimse `content_object` ag gach TaggEditem\` a thugann an réad a bhaineann leis, agus is féidir leat a shannadh don réimse sin nó é a úsáid agus TaggEditem\` á chruthú:

```pycon
>>> from django.contrib.auth.models import User
>>> guido = User.objects.get(username="Guido")
>>> t = TaggedItem(content_object=guido, tag="bdfl")
>>> t.save()
>>> t.content_object
<User: Guido>
```

Má scriostar an réad gaolmhar, fanann na réimsí `content_type` agus `object_id` socraithe dá luachanna bunaidh agus filleann `GenericForeignKey` `None`:

```pycon
>>> guido.delete()
>>> t.content_object  # returns None
```

Mar gheall ar an mbealach:class: ~django.contrib.contentTypes.Fields.GenericForeignKey a chuirtear i bhfeidhm, ní féidir leat réimsí den sórt sin a úsáid go díreach le scagairí (filter () \`\`agus \`\`eisiamh ()\`, mar shampla) tríd an API bunachar sonraí. Toisc nach gnáth-réad réimse é a:class: ~django.contrib.contentTypes.Fields.GenericForeignKey, ní oibreoidh na samplaí seo:

```pycon
# This will fail
>>> TaggedItem.objects.filter(content_object=guido)
# This will also fail
>>> TaggedItem.objects.get(content_object=guido)
```

Likewise, [`GenericForeignKey`](#django.contrib.contenttypes.fields.GenericForeignKey)s
do not appear in [`ModelForm`](/ga/5.2/topics/forms/modelforms/#django.forms.ModelForm)s.

### Caidreamh cineálach ar ais

#### `class GenericRelation`

#### `related_query_name`

Níl an gaol ar an réad gaolmhar ar ais leis an réad seo ann de réir réamhshocraithe. Cruthaíonn socrú `related_query_name` gaol ón réad gaolmhar ar ais leis an gceann seo. Ligeann sé seo fiosrú agus scagadh ón réad gaolmhar.

Má tá a fhios agat cé na samhlacha a bheidh á úsáid agat is minice, is féidir leat caidreamh cineálach “droim” a chur leis freisin chun API breise a chumasú. Mar shampla:

```
from django.contrib.contenttypes.fields import GenericRelation
from django.db import models

class Bookmark(models.Model):
    url = models.URLField()
    tags = GenericRelation(TaggedItem)
```

Beidh tréith `tags` ag gach cás `Leabharmharca`, ar féidir iad a úsáid chun a TaggEditems\` gaolmhara a aisghabháil:

```pycon
>>> b = Bookmark(url="https://www.djangoproject.com/")
>>> b.save()
>>> t1 = TaggedItem(content_object=b, tag="django")
>>> t1.save()
>>> t2 = TaggedItem(content_object=b, tag="python")
>>> t2.save()
>>> b.tags.all()
<QuerySet [<TaggedItem: django>, <TaggedItem: python>]>
```

Is féidir leat ```add () ``, `create ()```, nó set () a úsáid freisin chun caidrimh a chruthú:

```pycon
>>> t3 = TaggedItem(tag="Web development")
>>> b.tags.add(t3, bulk=False)
>>> b.tags.create(tag="Web framework")
<TaggedItem: Web framework>
>>> b.tags.all()
<QuerySet [<TaggedItem: django>, <TaggedItem: python>, <TaggedItem: Web development>, <TaggedItem: Web framework>]>
>>> b.tags.set([t1, t3])
>>> b.tags.all()
<QuerySet [<TaggedItem: django>, <TaggedItem: Web development>]>
```

Scriosfaidh an glao remove () mórchóir na rudaí samhail sonraithe:

```pycon
>>> b.tags.remove(t3)
>>> b.tags.all()
<QuerySet [<TaggedItem: django>]>
>>> TaggedItem.objects.all()
<QuerySet [<TaggedItem: django>]>
```

Is féidir an modh clear () a úsáid chun gach rud gaolmhara a scriosadh go mór mar shampla:

```pycon
>>> b.tags.clear()
>>> b.tags.all()
<QuerySet []>
>>> TaggedItem.objects.all()
<QuerySet []>
```

Sainmhínithe:Class: ~django.contrib.contentTypes.Fields.GenericRelation le tacar related\_query\_name\` ceadaíonn fiosrú ón réad gaolmhar:

```
tags = GenericRelation(TaggedItem, related_query_name="bookmark")
```

Cumasaíonn sé seo oibríochtaí scagtha, ordaithe agus fiosrúcháin eile ar ```Bookmark ``ó `TaggEditem```:

```pycon
>>> # Get all tags belonging to bookmarks containing `django` in the url
>>> TaggedItem.objects.filter(bookmark__url__contains="django")
<QuerySet [<TaggedItem: django>, <TaggedItem: python>]>
```

Mura gcuireann tú an `related_query_name` leis, is féidir leat na cineálacha céanna cuardaigh a dhéanamh de láimh:

```pycon
>>> bookmarks = Bookmark.objects.filter(url__contains="django")
>>> bookmark_type = ContentType.objects.get_for_model(Bookmark)
>>> TaggedItem.objects.filter(content_type__pk=bookmark_type.id, object_id__in=bookmarks)
<QuerySet [<TaggedItem: django>, <TaggedItem: python>]>
```

Díreach cosúil:class: ~django.contrib.contentTypes.Fields.GenericForeignKey glacann le hainmneacha na réimsí cineál ábhair agus Object-ID mar argóintí, mar sin freisin: class: ~django.contrib.contentTypes.Fields.GenericRelation; má tá an tsamhail a bhfuil an eochair eachtrach cineálach ag úsáid ainmneacha na réimsí sin, ní mór duit na n-ainmneacha a rith na réimsí agus a: aicme: .GenericRelation á bhunú leis. Mar shampla, má úsáideann an tsamhail `TaggEditem` dá dtagraítear thuas réimsí darb ainm content\_type\_fk\` agus object\_primary\_key\` chun a eochair eachtrach cineálach a chruthú, ansin caithfear a:class: .GenericRelation ar ais a shainiú mar sin:

```
tags = GenericRelation(
    TaggedItem,
    content_type_field="content_type_fk",
    object_id_field="object_primary_key",
)
```

Tabhair faoi deara freisin, má scriosann tú réad a bhfuil a:class: ~django.contrib.contentTypes.Fields.GenericRelation, scriosfar aon rudaí a bhfuil a:class: ~django.contrib.contentTypes.Fields.GenericForeignKey ag díriú air freisin. Sa sampla thuas, ciallaíonn sé seo dá scriosfaí réad `Leabharmharc`, go scriosfaí aon rudaí `TaggEditem` ag díriú air ag an am céanna.

Unlike:class: ~Django.db.Models.ForeignKey, :class: ~django.contrib.contentTypes.fields.GenericForeignKey ní ghlacann argóint a:attr: ~django.db.models.foreignKey.on\_delete chun an t-iompar seo a shaincheapadh; más mian leat, is féidir leat an cascade-scriosadh a sheachaint gan úsáid: class: ~django.contrib.contentTypes.Fields.GenericRelation, agus is féidir iompar malartach a sholáthar tríd an gcomhartha: data: ~django.db.models.signals.pre\_delete.

### Caidreamh cineálach agus comhiomlánú

[Django's database aggregation API](/ga/5.2/topics/db/aggregation/) works with a
[`GenericRelation`](#django.contrib.contenttypes.fields.GenericRelation). For example, you
can find out how many tags all the bookmarks have:

```pycon
>>> Bookmark.objects.aggregate(Count("tags"))
{'tags__count': 3}
```

### Gaol cineálach i bhfoirmeacha

Soláthraíonn an modúl:mod: django.contrib.contenttypes.forms:

- [`BaseGenericInlineFormSet`](#django.contrib.contenttypes.forms.BaseGenericInlineFormSet)
- Monarcha formset, :func: generic\_inlineformset\_factory, le húsáid le:class: ~django.contrib.contentTypes.Fields.GenericForeignKey.

#### `class BaseGenericInlineFormSet`

#### `generic_inlineformset_factory(model, form=ModelForm, formset=BaseGenericInlineFormSet, ct_field='content_type', fk_field='object_id', fields=None, exclude=None, extra=3, can_order=False, can_delete=True, max_num=None, formfield_callback=None, validate_max=False, for_concrete_model=True, min_num=None, validate_min=False, absolute_max=None, can_delete_extra=True)`

Tugann `GenericInlineFormSet` ar ais ag baint úsáid:func: ~django.forms.models.modelformset\_factory.

Ní mór duit `ct_field` agus `fk_field` a sholáthar má tá siad difriúil ó na réamhshocraithe, `content_type` agus `object_id` faoi seach. Tá paraiméadair eile cosúil leis na paraiméadair atá doiciméadaithe in:func: ~django.forms.models.modelformset\_factory agus:func: ~django.forms.models.inlineformset\_factory.

Freagraíonn an argóint for\_concrete\_model\` don argóint: ~django.contrib.contentTypes.Fields.GenericForeignKey.for\_Concrete\_Model ar GenericForeignKey\`.

### Caidreamh cineálach i riarachán

Soláthraíonn an modúl:mod: django.contrib.contenttypes.admin :class: ~django.contrib.contentTypes.admin.GenericTabularInline agus:class: ~django.contrib.contentTypes.admin.GenericStackedInline (fo-aicm:class: ~Django.Contrib.ContentTypes.ContentTypes.GenericInlineModelAdmin )

Cuireann na ranganna agus na feidhmeanna seo ar chumas caidreamh cineálach a úsáid i bhfoirmeacha agus an riarachán. \</topics/forms/modelforms\> \<using-generic-relations-as-an-inline\>Féach an doiciméadach:doc: model formset agus:ref: admin le haghaidh tuilleadh eolais.

#### `class GenericInlineModelAdmin`

Oidhreacht an aicme:Class: ~django.contrib.contentTypes.admin.GenericInlineModelAdmin gach airíonna ó aicme:class: ~django.contrib.admin.inlineModelAdmin aicme. Mar sin féin, cuireann sé cúpla ceann féin leis chun oibriú leis an ngaol cineálach:

#### `ct_field`

Ainm an: aicme: ~django.contrib.contentTypes.Models.contentType eochair réimse eachtrach ar an tsamhail. Réamhshocraithe go `content_type`.

#### `ct_fk_field`

Ainm an réimse sláimhir a léiríonn ID an réad gaolmhar. Réamhshocraithe go `object_id`.

#### `class GenericTabularInline`

#### `class GenericStackedInline`

Fo-aicmí de:class: GenericInlineModelAdmin le leagan amach cruachta agus táblaí, faoi seach.

### GenericPrefetch () \`\`

#### `class GenericPrefetch(lookup, querysets, to_attr=None)`

Tá an cuardach seo cosúil le ```Prefetch () ``agus níor chóir é a úsáid ach ar ``GenericForeignKey```. Glacann an argóint `Querysets` le liosta de na ceisteanna, gach ceann acu le haghaidh `Contenttype` difriúil. Tá sé seo úsáideach do GenericForeignKey\` le sraith torthaí neamh-aonchineálach.

```pycon
>>> from django.contrib.contenttypes.prefetch import GenericPrefetch
>>> bookmark = Bookmark.objects.create(url="https://www.djangoproject.com/")
>>> animal = Animal.objects.create(name="lion", weight=100)
>>> TaggedItem.objects.create(tag="great", content_object=bookmark)
>>> TaggedItem.objects.create(tag="awesome", content_object=animal)
>>> prefetch = GenericPrefetch(
...     "content_object", [Bookmark.objects.all(), Animal.objects.only("name")]
... )
>>> TaggedItem.objects.prefetch_related(prefetch).all()
<QuerySet [<TaggedItem: Great>, <TaggedItem: Awesome>]>
```