Resolver erros e avisos relacionados a parâmetros de tipo genéricos e argumentos de tipo genérico

Este artigo aborda os seguintes erros do compilador:

• CS0080: Não são permitidas restrições em declarações não genéricas.
• CS0081: A declaração de parâmetro de tipo deve ser um identificador e não um tipo.
• CS0224: Um método com vararg não pode ser genérico, ser de tipo genérico ou ter um parâmetro params.
• CS0304: Não é possível criar uma instância do tipo variável porque não tem a new() restrição.
• CS0305: Usar o tipo genérico requer argumentos do tipo N.
• CS0306: O tipo não pode ser usado como argumento de tipo.
• CS0307: O 'identificador' não pode ser usado com argumentos de tipo.
• CS0308: O tipo ou método não genérico não pode ser usado com argumentos de tipo.
• CS0310: O tipo deve ser um tipo não abstrato com um construtor público sem parâmetros para poder ser usado como parâmetro no tipo ou método genérico.
• CS0311:O tipo não pode ser usado como parâmetro T de tipo no tipo genérico ou método. Não existe conversão implícita de referência de 'tipo1' para 'tipo2'.
• CS0312: O tipo 'tipo1' não pode ser usado como parâmetro de tipo no tipo genérico ou método. O tipo anulável 'tipo1' não satisfaz a restrição de 'restrição'.
• CS0313: O tipo 'tipo1' não pode ser usado como parâmetro de tipo no tipo genérico ou método. O tipo anulável 'tipo1' não satisfaz a restrição de 'restrição'. Tipos anuláveis não conseguem satisfazer quaisquer restrições de interface.
• CS0314: O tipo não pode ser usado como parâmetro de tipo no tipo ou método genérico. Não existe conversão de boxing nem conversão de parâmetro de tipo de 'tipo' para 'restrição'.
• CS0315: O tipo não pode ser usado como parâmetro T de tipo no tipo genérico ou método. Não existe conversão no boxe de 'tipo' para 'restrição'.
• CS0401: A new() restrição deve ser a última restritiva especificada.
• CS0403: Não é possível converter nulo em parâmetro de tipo porque pode ser um tipo de valor não anulável. Considera usar default(T) em vez disso.
• CS0405: Restrição duplicada para o parâmetro de tipo.
• CS0406: A restrição do tipo de classe 'restrição' deve vir antes de quaisquer outras restrições.
• CS0409: Já foi especificada uma cláusula de restrição para o parâmetro de tipo 'parâmetro de tipo'. Todas as restrições para um parâmetro de tipo devem ser especificadas numa única cláusula where.
• CS0411:Os argumentos de tipo para o método 'método' não podem ser inferidos a partir do uso. Tenta especificar explicitamente o tipo de argumentos.
• CS0412: Parâmetro: um parâmetro, variável local ou função local não pode ter o mesmo nome que um parâmetro de tipo de método.
• CS0413: O parâmetro de tipo não pode ser usado com o as operador porque não tem uma restrição de tipo de classe nem uma class restrição.
• CS0417: Identificador: não pode fornecer argumentos ao criar uma instância de um tipo de variável.
• CS0449: As classrestrições , struct, unmanaged, notnull, e default não podem ser combinadas ou duplicadas, e devem ser especificadas primeiro na lista de restrições.
• CS0450: Parâmetro de Tipo: não pode especificar ambos uma classe de restrição e a restrição class ou struct.
• CS0451: A new() restrição não pode ser usada com a struct restrição.
• CS0452: O tipo 'nome do tipo' deve ser um tipo de referência para ser usado como parâmetro 'nome do parâmetro' no tipo genérico ou método 'genérico'.
• CS0453: O tipo 'nome do tipo' deve ser um tipo de valor não anulável para ser usado como parâmetro 'nome do parâmetro' no tipo genérico ou método 'genérico'.
• CS0454:Dependência circular de restrições envolvendo o Parâmetro de Tipo 1 e o Parâmetro de Tipo 2.
• CS0455: O parâmetro de tipo herda as restrições conflitantes 'restrição1' e 'restrição2'.
• CS0456: O parâmetro de tipo 'parâmetro de tipo 1' tem a restrição 'struct', pelo que o 'parâmetro de tipo 1' não pode ser usado como restrição para o 'parâmetro de tipo 2'.
• CS0693: O parâmetro de tipo 'parâmetro de tipo' tem o mesmo nome que o parâmetro de tipo do tipo externo 'tipo'.
• CS0694: O parâmetro de tipo tem o mesmo nome que o tipo ou método de contenção.
• CS0695: 'type' não pode implementar 'interface1' e 'interface2' porque, para algumas substituições de parâmetros de tipo, eles podem se unificar.
• CS0698: Um tipo genérico não pode derivar do tipo porque é uma classe de atributo.
• CS0699:'genérico' não define o parâmetro de tipo 'identificador'.
• CS0701: 'identificador' não é uma restrição válida. Um tipo usado como restrição deve ser uma interface, uma classe não selada ou um parâmetro de tipo.
• CS0702: A restrição não pode ser de classe especial.
• CS0703: Acessibilidade inconsistente: o tipo de restrição é menos acessível do que a declaração.
• CS0704: Não é possível fazer pesquisa de membro não virtual em 'type' porque é um parâmetro type.
• CS0706: Tipo de restrição inválido. Um tipo usado como restrição deve ser uma interface, uma classe não selada ou um parâmetro de tipo.
• CS0717: Classe estática: classes estáticas não podem ser usadas como restrições.
• CS0718: 'tipo': tipos estáticos não podem ser usados como argumentos de tipos.
• CS1720: A expressão causará sempre uma System.NullReferenceException porque o valor predefinido de 'tipo genérico' é nulo.
• CS1763: 'parâmetro' é do tipo 'tipo'. Um valor padrão de parâmetro de um tipo de referência diferente de string só pode ser inicializado com nulo.
• CS1948: A variável de intervalo 'name' não pode ter o mesmo nome que um parâmetro de tipo de método.
• CS1960: Modificador de variância inválido. Apenas os parâmetros de interface e de tipo delegado podem ser especificados como variantes.
• CS1961: Variância inválida: O parâmetro de tipo deve ser covariantemente válido no 'tipo'. 'parâmetro de tipo' é contravariante.
• CS3024: O tipo de restrição 'tipo' não é compatível com CLS.
• CS7002: Uso inesperado de um nome genérico.
• CS8322: Não é possível passar argumentos com tipo dinâmico para uma função local genérica com argumentos de tipo inferido.
• CS8375: A restrição 'new()' não pode ser usada com a restrição 'não gerida'.
• CS8377: O tipo 'tipo' tem de ser um tipo de valor não anulável, bem como todos os campos, em qualquer nível de aninhamento, para o poder utilizar como parâmetro 'parâmetro' no tipo genérico ou método 'genérico'.
• CS8379: O parâmetro de tipo 'parâmetro de tipo 1' tem a restrição 'não gerida', pelo que o 'parâmetro de tipo 1' não pode ser usado como restrição para o 'parâmetro de tipo 2'.
• CS8380: 'type': não pode especificar tanto uma classe de restrição como a restrição 'não gerida'.
• CS8387: Parâmetro de tipo 'parâmetro de tipo' tem o mesmo nome do parâmetro de tipo do método externo 'método'.
• CS8389: Omitir o argumento do tipo não é permitido no contexto atual.
• CS8427: Enums, classes e estruturas não podem ser declarados numa interface que tenha um parâmetro do tipo 'in' ou 'out'.
• CS8665: O método 'method' especifica uma restrição 'class' para o parâmetro de tipo 'type parameter', mas o parâmetro de tipo correspondente 'type parameter' do método 'method' substituído ou explicitamente implementado não é um tipo de referência.
• CS8666: O método 'method' especifica uma restrição 'struct' para o parâmetro de tipo 'type parameter', mas o parâmetro de tipo correspondente 'type parameter' do método 'method' substituído ou implementado explicitamente não é um tipo de valor não anulável.
• CS8822: O método 'method' especifica uma restrição 'default' para o parâmetro de tipo 'type parameter', mas o parâmetro de tipo correspondente 'type parameter' do método 'method' substituído ou implementado explicitamente está restringido a um tipo de referência ou a um tipo de valor.
• CS8823: A restrição 'default' só é válida em métodos de substituição e em métodos de implementação explícita de interfaces.
• CS8893: 'type' não é um tipo válido de convenção de chamada para 'UnmanagedCallersOnly'.
• CS8894: Não é possível usar 'type' como parâmetro ou tipo de retorno num método atribuído com 'UnmanagedCallersOnly'.
• CS8895: Os métodos atribuídos com 'UnmanagedCallersOnly' não podem ter parâmetros genéricos de tipo nem podem ser declarados num tipo genérico.
• CS8896: 'UnmanagedCallersOnly' só pode ser aplicado a métodos estáticos não abstratos, não virtuais ou a funções locais estáticas.
• CS9011: Palavra-chave delegate não pode ser usada como restrição. Querias dizer System.Delegate?
• CS9012: Palavra-chave record inesperada. Queria dizer record struct ou record class?
• CS9338: Acessibilidade inconsistente: o tipo é menos acessível do que a classe.

Declaração de parâmetro de tipo e nomenclatura

• CS0080: Não são permitidas restrições em declarações não genéricas.
• CS0081: A declaração de parâmetro de tipo deve ser um identificador e não um tipo.
• CS0412: Parâmetro: um parâmetro, variável local ou função local não pode ter o mesmo nome que um parâmetro de tipo de método.
• CS0693: O parâmetro de tipo 'parâmetro de tipo' tem o mesmo nome que o parâmetro de tipo do tipo externo 'tipo'.
• CS0694: O parâmetro de tipo tem o mesmo nome que o tipo ou método de contenção.
• CS0699:'genérico' não define o parâmetro de tipo 'identificador'.
• CS1948: A variável de intervalo 'name' não pode ter o mesmo nome que um parâmetro de tipo de método.
• CS8387: Parâmetro de tipo 'parâmetro de tipo' tem o mesmo nome do parâmetro de tipo do método externo 'método'.
• CS9012: Palavra-chave record inesperada. Queria dizer record struct ou record class?

Estes erros relacionam-se com a forma como declaras e nomeas parâmetros de tipo em tipos e métodos genéricos. Os nomes dos parâmetros de tipo devem ser identificadores válidos, não podem entrar em conflito com outros identificadores no âmbito e devem aparecer na lista de parâmetros de tipo da declaração.

• Remova a cláusula de restrição de declarações não genéricas (CS0080). A where cláusula só pode ser usada em tipos genéricos e métodos que declaram parâmetros de tipo. Se você precisar aplicar restrições, primeiro adicione parâmetros de tipo à sua declaração de tipo ou método.
• Substitua nomes de tipo reais por identificadores em declarações de parâmetro de tipo (CS0081). Deve declarar parâmetros de tipo usando identificadores (como T, , ou TKey) em vez de tipos concretos (como TValue ou intstring). O objetivo de um parâmetro de tipo é servir como um marcador que o compilador substitui por tipos reais quando o tipo ou método genérico é utilizado.
• Renomear parâmetros de tipo, variáveis locais, parâmetros ou variáveis de intervalo para evitar conflitos de nomeação (CS0412, CS0694,CS1948). Os nomes dos parâmetros de tipo não podem ocultar identificadores no mesmo âmbito, nem ter o mesmo nome que o tipo ou método envolvente. As variáveis de intervalo LINQ também não podem reutilizar o nome do parâmetro de tipo de um método. Tais conflitos criam ambiguidade sobre qual identificador está sendo referenciado.
• Use um nome diferente para parâmetros internos que sombreiam os exteriores (CS0693, CS8387). Quando um membro genérico (como um método ou tipo aninhado) está dentro de uma classe ou método genérico, o parâmetro de tipo interno não é necessariamente o mesmo que o externo. Dar-lhes o mesmo nome cria confusão sobre qual parâmetro de tipo está a ser referenciado. Use um nome distinto para o parâmetro de tipo interno.
• Assegure que todos os parâmetros de tipo nas cláusulas de restrição são declarados na lista de parâmetros de tipo (CS0699). Uma where cláusula só pode referenciar parâmetros de tipo que aparecem na declaração genérica. Se o nome na where cláusula não corresponder a nenhum parâmetro de tipo declarado, verifique se há erros de digitação ou erros ortográficos.
• Use a sintaxe correta de declaração de registo (CS9012). Ao declarar um tipo de registo, deve usar ou record class ou record struct (ou apenas record para um tipo de referência). A record palavra-chave sozinha não pode aparecer em posições onde o compilador espera uma sintaxe de declaração diferente.

Para obter mais informações, consulte Generic Type Parameters and Generics.

Declaração de restrições e ordenação

• CS0401: A new() restrição deve ser a última restritiva especificada.
• CS0406: A restrição de tipo de classe 'constraint' deve vir antes de todas as outras restrições.
• CS0409: Já foi especificada uma cláusula de restrição para o parâmetro de tipo 'parâmetro de tipo'. Todas as restrições para um parâmetro de tipo devem ser especificadas numa única cláusula where.
• CS0449: As classrestrições , struct, unmanaged, notnull, e default não podem ser combinadas ou duplicadas, e devem ser especificadas primeiro na lista de restrições.
• CS0450: Parâmetro de Tipo: não pode especificar ambos, uma classe de restrição e as restrições class ou struct simultaneamente.
• CS0451: A new() restrição não pode ser usada com a struct restrição.
• CS8375: A restrição 'new()' não pode ser usada com a restrição 'não gerida'.
• CS8380: 'type': não pode especificar tanto uma classe de restrição como a restrição 'não gerida'.
• CS9011: Palavra-chave delegate não pode ser usada como restrição. Querias dizer System.Delegate?

As restrições dos parâmetros de tipo devem seguir uma ordem específica: as restrições primárias (class, struct, unmanaged, notnull ou default) surgem primeiro, depois uma restrição de tipo de classe, seguida de restrições de interface e, por fim, a restrição de construtor new(). Algumas restrições são mutuamente exclusivas e não podem ser combinadas. Todas as restrições para um único parâmetro de tipo devem aparecer numa única where cláusula.

• Coloque a new() restrição no final da lista de restrições (CS0401). A new() restrição deve aparecer após todas as outras restrições. Por exemplo, altere where T : new(), IDisposable para where T : IDisposable, new().
• Coloque a restrição do tipo de classe antes das restrições de interface (CS0406). Quando se restringe um parâmetro de tipo a uma classe base específica juntamente com interfaces, a classe deve aparecer primeiro. Por exemplo, altere where T : IDisposable, MyBaseClass para where T : MyBaseClass, IDisposable.
• Combine todas as restrições de um parâmetro de tipo numa única where cláusula (CS0409). Não podes usar múltiplas where cláusulas para o mesmo tipo de parâmetro. Junte-os numa única oração: mudar where T : I where T : new() para where T : I, new(). Múltiplas where cláusulas só são válidas quando visam parâmetros de tipo diferentes.
• Coloque as restrições primárias primeiro e não combine restrições mutuamente exclusivas (CS0449). Pode especificar no máximo um de class, struct, unmanaged, notnull, ou default, e deve aparecer primeiro na lista de restrições. As restrições class e struct são mutuamente exclusivas, assim como o são class e unmanaged.
• Não combine uma restrição de classe específica com class, struct, ou unmanaged (CS0450, CS8380). Se um parâmetro de tipo estiver restringido a um tipo de classe específico, é implicitamente um tipo de referência, o que contradiz a restrição struct ou unmanaged. Remova a restrição de classe ou a restrição primária.
• Não combines new() com struct ou unmanaged (CS0451, CS8375). Todos os tipos de valores têm implicitamente um construtor público sem parâmetros, pelo que a new() restrição é redundante quando combinada com struct. O mesmo se aplica a unmanaged, o que implica struct. Remova a new() restrição.
• Substitua delegate por System.Delegate cláusulas de restrição (CS9011). A delegate palavra-chave é usada para declarar tipos de delegados, não como uma restrição. Para restringir um parâmetro de tipo a delegar tipos, use System.Delegate como tipo de restrição.

Para obter mais informações, consulte Restrições em parâmetros de tipo.

Tipos de restrições válidos

• CS0405: Restrição duplicada para o parâmetro de tipo.
• CS0701: 'identificador' não é uma restrição válida. Um tipo usado como restrição deve ser uma interface, uma classe não selada ou um parâmetro de tipo.
• CS0702: A restrição não pode ser de classe especial.
• CS0703: Acessibilidade inconsistente: o tipo de restrição é menos acessível do que a declaração.
• CS0706: Tipo de restrição inválido. Um tipo usado como restrição deve ser uma interface, uma classe não selada ou um parâmetro de tipo.
• CS0717: Classe estática: classes estáticas não podem ser usadas como restrições.
• CS3024: O tipo de restrição 'type' não é compatível com CLS.

Uma restrição deve ser uma interface, uma classe não selada ou um parâmetro de tipo. Certos tipos são inválidos como restrições devido ao seu significado especial no sistema de tipos .NET ou porque não podem ser herdados.

• Remover restrições duplicadas (CS0405). Cada restrição só pode aparecer uma vez numa cláusula de restrição. Se tiver where T : I, I, remove o duplicado.
• Use apenas tipos não selados como restrições (CS0701). Classes seladas, estruturas e enums não podem ser herdados, por isso não servem para nada como restrições. Use uma interface que os tipos desejados implementem, ou use uma classe base não selada.
• Não uses classes especiais como restrições (CS0702). Os tipos Object, Array, e ValueType não podem ser usados como restrições. Todo tipo já deriva de Object, por isso restringir-se a ele não fornece valor. Array e ValueType são tipos base abstratos que não podem ser herdados diretamente. Se precisares de comportamento semelhante a um array, usa IList<T> ou IEnumerable<T> em vez disso.
• Garantir que os tipos de restrições são pelo menos tão acessíveis quanto o tipo genérico (CS0703). Um tipo genérico público não pode ter restrições usando tipos internos, porque código externo não conseguiria fornecer argumentos de tipo válidos. Ou torna o tipo de restrição público, ou reduz a acessibilidade do tipo genérico.
• Use apenas interfaces, classes não seladas ou parâmetros de tipo como restrições (CS0706). Não podes usar arrays, classes seladas, structs, enums ou outros tipos inválidos como restrições. Considere usar uma interface que os tipos desejados implementem.
• Não uses classes estáticas como restrições (CS0717). As classes estáticas não podem ser estendidas porque só contêm membros estáticos. Nenhum tipo pode derivar de uma classe estática, tornando-a inútil como restrição.
• Use um tipo compatível com CLS para a restrição de tipo (CS3024). Quando um assembly é marcado com [assembly: CLSCompliant(true)], a utilização de um tipo não compatível com CLS como restrição de tipo genérico pode tornar impossível que código escrito em determinadas linguagens utilize a sua classe genérica.

Para obter mais informações, consulte Restrições em parâmetros de tipo.

Satisfação de restrições e conversões

• CS0311:O tipo não pode ser usado como parâmetro T de tipo no tipo genérico ou método. Não existe conversão implícita de referência de 'tipo1' para 'tipo2'.
• CS0312: O tipo não pode ser usado como parâmetro de tipo no tipo genérico ou método. O tipo nulo não satisfaz a restrição de 'restrição'.
• CS0313: O tipo não pode ser usado como parâmetro de tipo no tipo genérico ou método. O tipo nulo não satisfaz a restrição de 'restrição'. Tipos anuláveis não conseguem satisfazer quaisquer restrições de interface.
• CS0314: O tipo não pode ser usado como parâmetro de tipo no tipo genérico ou no método. Não existe conversão de boxing nem conversão de parâmetro de tipo de 'tipo' para 'restrição'.
• CS0315: O tipo não pode ser usado como parâmetro T de tipo no tipo genérico ou método. Não existe conversão no boxe de 'tipo' para 'restrição'.
• CS0452: O tipo 'nome do tipo' deve ser um tipo de referência para ser usado como parâmetro 'nome do parâmetro' no tipo genérico ou método 'genérico'.
• CS0453: O tipo 'nome do tipo' deve ser um tipo de valor não anulável para ser usado como parâmetro 'nome do parâmetro' no tipo genérico ou método 'genérico'.
• CS8377:O tipo 'tipo' deve ser um tipo de valor não anulável, juntamente com todos os campos em qualquer nível de aninhamento, para que possa ser usado como parâmetro 'parâmetro' no tipo genérico ou método 'genérico'.

Estes erros ocorrem quando um argumento de tipo não satisfaz as restrições declaradas num parâmetro de tipo genérico. O argumento do tipo deve ter as conversões, relações de herança e propriedades estruturais corretas para corresponder a todas as restrições.

• Altere o argumento type para um que tenha uma conversão de referência implícita para o tipo de restrição (CS0311). Quando um parâmetro de tipo tem uma restrição como where T : BaseType, qualquer argumento de tipo deve ser convertível em BaseType por meio de uma conversão de referência implícita ou conversão de identidade. As conversões numéricas implícitas (como de short para int) não satisfazem as restrições genéricas dos parâmetros de tipo.
• Use tipos de valor não anuláveis ou altere o tipo de restrição (CS0312, CS0313). Os tipos de valor anulável (como int?) são distintos de seus tipos de valor subjacentes e não satisfazem as mesmas restrições. Os tipos de valor nulo não conseguem satisfazer restrições de interface porque o próprio wrapper nullable não implementa a interface. Use a forma não anulável do tipo de valor como argumento do tipo.
• Repita as restrições de parâmetro de tipo da classe base em qualquer declaração de classe derivada (CS0314). Quando uma classe genérica derivada herda de uma classe genérica base restrita, a classe derivada deve declarar as mesmas restrições nos seus parâmetros de tipo correspondentes.
• Certifique-se de que os argumentos de tipo satisfaçam as restrições de tipo ou classe de referência (CS0315). Quando um parâmetro de tipo está limitado a um tipo de classe, não é possível usar um tipo de valor (estrutura) como argumento de tipo, porque não existe uma conversão de boxing que satisfaça essa relação de restrição. Use um tipo de referência que herde ou implemente a restrição.
• Use um tipo de referência como argumento de tipo quando a class restrição for especificada (CS0452). Tipos de valor como struct ou int não podem satisfazer uma class restrição. Ou muda o argumento do tipo para um tipo de referência, ou remove a class restrição se o tipo genérico puder funcionar com tipos de valor.
• Use um tipo de valor não anulável como argumento de tipo quando a struct restrição for especificada (CS0453). Tipos de referência, tipos de valor nulo (int?) e outros tipos sem valor não podem satisfazer uma struct restrição. Utilize um tipo de valor concreto, não anulável, como int, double ou um tipo struct definido pelo utilizador.
• Use um tipo cujos campos sejam todos tipos não geridos quando a unmanaged restrição for especificada (CS8377). A restrição unmanaged requer um tipo de valor não anulável em que cada campo, em todos os níveis de aninhamento, seja também um tipo não gerido. Tipos que contêm campos de tipo de referência ou parâmetros de tipo genérico que não se sabe serem não geridos não satisfazem esta restrição.

Para obter mais informações, consulte Restrições em parâmetros de tipo.

Conflitos de restrições e dependências circulares

• CS0454:Dependência circular de restrições envolvendo o Parâmetro de Tipo 1 e o Parâmetro de Tipo 2.
• CS0455: O parâmetro de tipo herda as restrições conflitantes 'restrição1' e 'restrição2'.
• CS0456: O parâmetro de tipo 'parâmetro de tipo 1' tem a restrição 'struct', pelo que o 'parâmetro de tipo 1' não pode ser usado como restrição para o 'parâmetro de tipo 2'.
• CS8379: O parâmetro de tipo 'parâmetro de tipo 1' tem a restrição 'não gerida', pelo que o 'parâmetro de tipo 1' não pode ser usado como restrição para o 'parâmetro de tipo 2'.

As restrições não podem criar dependências circulares, e os parâmetros de tipo não podem herdar restrições conflitantes que são impossíveis de satisfazer simultaneamente. As restrições de tipo de valor (struct e unmanaged) são implicitamente seladas, pelo que não podem ser usadas como restrições em outros parâmetros de tipo.

• Remover dependências circulares de restrições (CS0454). Um parâmetro de tipo não pode depender direta ou indiretamente de si próprio através das suas restrições. Por exemplo, where T : U where U : T cria uma dependência circular. Quebra o ciclo removendo uma das restrições.
• Remover restrições herdadas conflitantes (CS0455). Um parâmetro de tipo não pode ser limitado a múltiplas classes não relacionadas, porque C# não suporta herança múltipla de classes. Da mesma forma, não pode ser limitada a ambos struct e a um tipo de classe. Reestrutura a hierarquia de tipos ou remove uma das restrições conflitantes.
• Não utilize um parâmetro de tipo com restrição struct ou um parâmetro de tipo com restrição unmanaged como restrição de outro parâmetro de tipo (CS0456, CS8379). As restrições dos tipos de valor são implicitamente seladas, pelo que nenhum outro tipo pode derivar delas. Para resolver este erro, coloque o tipo de valor ou restrição não gerida diretamente no segundo parâmetro de tipo, em vez de o restringir indiretamente através do primeiro parâmetro de tipo.

Para obter mais informações, consulte Restrições em parâmetros de tipo.

Regras de sobreposição e restrições de implementação

• CS8665: O método 'method' especifica uma restrição 'class' para o parâmetro de tipo 'type parameter', mas o parâmetro de tipo correspondente 'type parameter' do método 'method' substituído ou implementado explicitamente não é um tipo de referência.
• CS8666: O método 'method' especifica uma restrição 'struct' para o parâmetro de tipo 'type parameter', mas o parâmetro de tipo correspondente 'type parameter' do método 'method' substituído ou implementado explicitamente não é um tipo de valor não anulável.
• CS8822: O método 'method' especifica uma restrição 'default' para o parâmetro de tipo 'type parameter', mas o parâmetro de tipo correspondente 'type parameter' do método 'method' substituído ou implementado explicitamente está restrito a um tipo de referência ou a um tipo de valor.
• CS8823: A restrição 'default' é válida apenas em métodos de sobrescrita e de implementação explícita de interface.

Quando sobrescreve um método virtual ou implementa explicitamente um método de interface, as restrições sobre os parâmetros de tipo do método sobreposto devem ser compatíveis com as restrições do método base. A restrição default é um modificador especial usado apenas em cenários de substituição e de implementação explícita de interface para indicar que um parâmetro de tipo não tem nem a restrição class nem a restrição struct.

• Assegure que as restrições do método sobreposto correspondem às restrições do método base (CS8665, CS8666). Uma substituição não pode adicionar a restrição class se o parâmetro de tipo correspondente do método de base não estiver restringido a um tipo de referência. De forma semelhante, não pode adicionar uma struct restrição se o parâmetro de tipo do método base não estiver restrito a um tipo de valor. A sobreposição deve ser compatível com a declaração base.
• Use a default restrição apenas quando o parâmetro de tipo do método base não estiver restrito (CS8822). A restrição default indica que o parâmetro de tipo não tem restrição class nem struct. Não podes aplicar default se o parâmetro de tipo correspondente do método substituído já tiver uma restrição class ou struct.
• Utilize a restrição default apenas em métodos de substituição ou em métodos de implementação explícita de interfaces (CS8823). A default restrição não é válida em declarações de métodos regulares. Serve especificamente para desambiguar ao substituir um método em que a classe base tinha um parâmetro de tipo não restringido, sendo necessário indicar que a substituição também o deixa não restringido.

Para mais informações, veja Restrições nos parâmetros de tipo e na default restrição.

Restrições do construtor

• CS0304: Não é possível criar uma instância do tipo variável porque não tem a new() restrição.
• CS0310: O tipo deve ser um tipo não abstrato com um construtor público sem parâmetros para poder ser usado como parâmetro no tipo ou método genérico.
• CS0417: Identificador: não pode fornecer argumentos ao criar uma instância de um tipo de variável.

Estes erros relacionam-se com a new() restrição e a instanciação dos parâmetros do tipo com o new operador.

• Adicione a new() restrição aos parâmetros de tipo que precisa de instanciar (CS0304). Quando usa new T() dentro de um tipo ou método genérico, o compilador deve garantir que qualquer argumento de tipo tem um construtor sem parâmetros. A new() restrição oferece esta garantia.
• Garantir que os argumentos de tipo tenham construtores públicos sem parâmetros (CS0310). Quando um parâmetro de tipo tem a new() restrição, qualquer tipo concreto usado como argumento de tipo deve ser não abstrato e deve fornecer um construtor público sem parâmetros. Tipos com apenas construtores privados, protegidos ou parametrizados não conseguem satisfazer a new() restrição.
• Remova os argumentos do construtor ao instanciar parâmetros de tipo (CS0417). A new() restrição apenas garante um construtor sem parâmetros. Não podes apresentar argumentos a new T(arguments). Se precisar de construir instâncias com argumentos específicos, considere usar um padrão de fábrica ou uma restrição de interface que defina o comportamento de construção.

Para mais informações, veja Restrições nos parâmetros de tipo e na new() restrição.

Contagem e utilização de argumentos de tipo em programação

• CS0224: Um método com vararg não pode ser genérico, ser de tipo genérico ou ter um parâmetro params.
• CS0305: Usar o tipo genérico requer argumentos do tipo N.
• CS0306: O tipo não pode ser usado como argumento de tipo.
• CS0307: O 'identificador' não pode ser usado com argumentos de tipo.
• CS0308: O tipo ou método não genérico não pode ser usado com argumentos de tipo.
• CS7002: Uso inesperado de um nome genérico.
• CS8389: Omitir o argumento do tipo não é permitido no contexto atual.

Estes erros relacionam-se com fornecer o número e tipo corretos de argumentos a tipos e métodos genéricos.

• Remova parâmetros de tipo genéricos ou que contenham declarações de tipo genéricas de métodos que usam __arglist (CS0224). A __arglist palavra-chave é incompatível com genéricos porque os mecanismos de tempo de execução para manipular listas de argumentos variáveis entram em conflito com a substituição de tipo necessária para parâmetros de tipo genéricos.
• Forneça o número exato de argumentos de tipo especificado na declaração genérica (CS0305). Cada parâmetro genérico de tipo na definição deve ter um argumento de tipo correspondente quando o tipo genérico é instanciado.
• Use apenas tipos válidos como argumentos de tipo (CS0306). Tipos de ponteiro (como int* ou char*) não podem ser usados como argumentos de tipo porque tipos genéricos requerem tipos geridos que o coletor de lixo pode rastrear.
• Remova a sintaxe do argumento de tipo de construções não genéricas (CS0307, CS0308). Argumentos de tipo contidos entre colchetes de ângulo só podem ser aplicados a tipos genéricos e métodos que declaram parâmetros de tipo. Certifique-se de importar o namespace que contém a versão genérica do tipo.
• Remover parâmetros de tipo das declarações que não suportam genéricos (CS7002). Alguns construtos, como os enums, não podem ser genéricos. Se precisares de um contêiner genérico para valores de enum, considera usar uma classe ou uma struct genérica.
• Forneça explicitamente todos os argumentos de tipo necessários (CS8389). Em alguns contextos, como ao usar o typeof operador ou criar delegados, deve fornecer todos os argumentos de tipo e não os pode omitir. Por exemplo, use typeof(List<int>) em vez de tentar omitir o argumento do tipo.

Para obter mais informações, consulte Generic Type Parameters and Generics.

Inferência de tipos de argumentos

• CS0411:Os argumentos de tipo para o método 'método' não podem ser inferidos a partir do uso. Tenta especificar explicitamente o tipo de argumentos.

Este erro ocorre quando chamas um método genérico sem fornecer explicitamente os argumentos de tipo e o compilador não consegue inferir quais os argumentos de tipo que pretendes. O compilador infere os argumentos de tipo a partir dos tipos dos argumentos do método que fornece no ponto de chamada.

• Especifique explicitamente os argumentos de tipo entre colchetes angulares (CS0411). Se o compilador não conseguir determinar os argumentos de tipo a partir dos argumentos do método, forneça-os diretamente. Por exemplo, altere G() para G<int>(). Este erro ocorre frequentemente quando um método genérico não tem parâmetros a partir dos quais inferir o tipo, ou quando um null argumento é passado e o compilador não consegue determinar o tipo pretendido.

Para obter mais informações, consulte Métodos genéricos.

Variância do parâmetro de tipo

• CS1960: Modificador de variância inválido. Apenas os parâmetros de interface e de tipo delegado podem ser especificados como variantes.
• CS1961: Variância inválida: O parâmetro de tipo deve ser covariantemente válido no 'tipo'. 'parâmetro de tipo' é contravariante.
• CS8427: Enums, classes e estruturas não podem ser declarados numa interface que tenha um parâmetro do tipo 'in' ou 'out'.

Modificadores de variância (in para contravariância, out para covariância) controlam como podes usar parâmetros de tipo na interface e delegar declarações. Apenas interfaces e delegados suportam variância. Um parâmetro de tipo covariante (out) só pode aparecer em posições de saída (tipos de retorno), enquanto um parâmetro de tipo contravariante (in) só pode aparecer em posições de entrada (tipos de parâmetro).

• Use modificadores de variância apenas nos parâmetros de interface e de tipo de delegação (CS1960). Classes, estruturas e outras declarações de tipo não suportam modificadores de variância. Apenas as declarações interface e delegate podem usar in ou out nos seus parâmetros de tipo.
• Use out (covariante) para parâmetros de tipo que apenas aparecem nos tipos de retorno, e in (contravariante) para parâmetros de tipo que só aparecem nos tipos de parâmetros (CS1961). Se o parâmetro de tipo tiver de aparecer tanto nas posições de entrada como de saída, remova o modificador de variância.
• Não declare enums, classes ou estruturas dentro de uma interface variante (CS8427). As declarações de tipos aninhados numa interface que tenha parâmetros de tipo in ou out não são permitidas, porque podem violar as regras de segurança da variância. Mover o tipo aninhado para fora da declaração de interface.

Para mais informações, veja Covariância e Contravariância em Genéricos.

Restrições de uso de tipo genérico

• CS0403: Não é possível converter nulo em parâmetro de tipo porque pode ser um tipo de valor não anulável. Considera usar default(T) em vez disso.
• CS0413: O parâmetro de tipo não pode ser usado com o as operador porque não tem uma restrição de tipo de classe nem uma class restrição.
• CS0695: 'type' não pode implementar tanto 'interface1' como 'interface2' porque elas podem combinar-se para algumas substituições de parâmetros de tipo.
• CS0698: Um tipo genérico não pode derivar do tipo porque é uma classe de atributo.
• CS0704: Não é possível fazer pesquisa de membro não virtual em 'type' porque é um parâmetro type.
• CS0718: 'tipo': tipos estáticos não podem ser usados como argumentos de tipos.
• CS1720: A expressão irá sempre causar uma exceção System.NullReferenceException porque o valor predefinido de 'tipo genérico' é nulo.
• CS1763: 'parâmetro' é do tipo 'tipo'. Um valor padrão de parâmetro de um tipo de referência diferente de string só pode ser inicializado com nulo.
• CS8322: Não é possível passar argumentos com tipo dinâmico para uma função local genérica com argumentos de tipo inferido.
• CS9338: Acessibilidade inconsistente: o tipo é menos acessível do que a classe.

Estes erros relacionam-se com restrições sobre como tipos genéricos e parâmetros de tipo podem ser usados em expressões, herança e acesso a membros.

• Substituir null as atribuições por default(T) ou adicionar uma class restrição (CS0403). Quando atribui null a um parâmetro de tipo não restrito, o compilador não pode garantir que o argumento de tipo é um tipo de referência. Use default(T), que fornece o valor padrão apropriado para qualquer tipo, ou adicione uma class restrição se precisar especificamente de semântica de tipo de referência.
• Adicione uma restrição de class tipo ou específica ao usar o as operador (CS0413). O as operador retorna null se a conversão falhar, mas os tipos de valor não podem ser null. Adicionar uma class restrição para garantir que o parâmetro de tipo é sempre um tipo de referência.
• Evite implementar a mesma interface genérica várias vezes com parâmetros de tipo que poderiam unificar (CS0695). Quando uma classe implementa uma interface genérica várias vezes com diferentes parâmetros de tipo (como class G<T1, T2> : I<T1>, I<T2>), instanciar com o mesmo tipo para ambos os parâmetros criaria um conflito. Implementar a interface apenas uma vez, ou reestruturar para evitar a unificação.
• Remova parâmetros de tipo genéricos de classes de atributo (CS0698). Este erro não é mais produzido nas versões atuais do C#, pois os atributos genéricos agora são suportados.
• Utilize o tipo de restrição concreta em vez do parâmetro tipo para acesso aninhado (CS0704). Não pode aceder a tipos aninhados ou a membros não virtuais através de um parâmetro de tipo. Em vez de T.InnerType, usa diretamente o tipo de restrição conhecido, como BaseClass.InnerType.
• Não uses tipos estáticos como argumentos de tipo (CS0718). Tipos estáticos não podem ser instanciados nem usados como argumentos genéricos. Remove o tipo estático do argumento genérico.
• Evite chamar membros da instância quando default(T)T está limitado a um tipo de referência (CS1720). Quando T tem uma restrição class, default(T) é null, pelo que chamar membros de instância nele gera sempre um NullReferenceException. Adicionar uma verificação de nulo antes de chamar os membros, ou reestruturar o código para evitar usar default(T) diretamente.
• Use null como valor padrão de parâmetro para parâmetros opcionais cujo tipo é um tipo de referência (CS1763). Se um método genérico tiver um parâmetro do tipo T e T for um tipo de referência, substitua default(U) por null porque os parâmetros predefinidos opcionais devem ser constantes em tempo de compilação, e default(T) isso não resolve esse requisito.
• Especifique explicitamente argumentos de tipo ao passar valores dinâmicos para funções locais genéricas (CS8322). Quando se passa um dynamic argumento para uma função local genérica, o compilador não consegue inferir argumentos de tipo. Especifique explicitamente o argumento tipo ou conjure o valor dinâmico.
• Garantir que os argumentos de tipo usados em assinaturas públicas ou protegidas sejam pelo menos tão acessíveis quanto o membro (CS9338). Um membro genérico público deve usar argumentos de tipo que sejam acessíveis ao público. Ou torna público o tipo de argumento, ou reduz a acessibilidade do membro.

Para mais informações, consulte Restrições nos parâmetros de tipo e expressões de valores padrão.

UnmanagedCallersOnly Restrições

• CS8893: 'type' não é um tipo válido de convenção de chamada para 'UnmanagedCallersOnly'.
• CS8894: Não é possível usar 'type' como parâmetro ou tipo de retorno num método atribuído com 'UnmanagedCallersOnly'.
• CS8895: Os métodos atribuídos com 'UnmanagedCallersOnly' não podem ter parâmetros genéricos de tipo nem podem ser declarados num tipo genérico.
• CS8896: 'UnmanagedCallersOnly' só pode ser aplicado a métodos estáticos não abstratos, não virtuais ou a funções locais estáticas.

O UnmanagedCallersOnlyAttribute atributo marca métodos que o código não gerido pode chamar. Estes métodos têm requisitos rigorosos porque o tempo de execução deve gerir a transição entre convenções de chamadas geridas e não geridas.

• Use apenas tipos válidos de convenção de chamada no UnmanagedCallersOnly atributo (CS8893). A propriedade CallConvs do atributo aceita apenas tipos reconhecidos de convenção de chamada no espaço de nomes System.Runtime.CompilerServices.
• Utilize apenas tipos blittable como tipos de parâmetro e de retorno (CS8894). Os métodos marcados com UnmanagedCallersOnly não podem usar tipos geridos (como string ou object) como tipos de parâmetros ou de retorno, porque o código chamador não gerido não consegue gerir as referências sujeitas à recolha de lixo.
• Remova parâmetros genéricos de tipo dos UnmanagedCallersOnly métodos e não os declare em tipos genéricos (CS8895). As convenções de chamadas não geridas não suportam genéricos porque o runtime não consegue determinar a convenção correta para substituições de tipos genéricos.
• Aplica-se UnmanagedCallersOnly apenas a métodos estáticos, não abstratos, não virtuais ou funções locais estáticas (CS8896). Métodos de instância, métodos abstratos e métodos virtuais não podem ser marcados UnmanagedCallersOnly porque os chamadores não geridos não conseguem realizar os mecanismos de despacho que estes métodos exigem.

Para obter mais informações, veja UnmanagedCallersOnlyAttribute.