Lösa fel och varningar som rör generiska typparametrar och argument av allmän typ

Den här artikeln beskriver följande kompilatorfel:

• CS0080: Begränsningar tillåts inte för icke-generiska deklarationer.
• CS0081: Typparameterdeklarationen måste vara en identifierare, inte en typ.
• CS0224: En metod med vararg kan inte vara generisk, vara av allmän typ eller ha en params-parameter.
• CS0304: Det går inte att skapa en instans av variabeltypen eftersom den inte har villkoret new() .
• CS0305: Användning av den allmänna typen kräver argument av N-typ.
• CS0306: Typen kanske inte används som ett typargument.
• CS0307: Identifieraren kan inte användas med typargument.
• CS0308: Den icke-generiska typen eller metoden kan inte användas med typargument.
• CS0310: Typen måste vara en icke-abstrakt typ med en offentlig parameterlös konstruktor för att kunna använda den som parameter i den generiska typen eller metoden.
• CS0311: Typen kan inte användas som typparameter T i den generiska typen eller metoden. Det finns ingen implicit referenskonvertering från "type1" till "type2".
• CS0312: Typen "type1" kan inte användas som typparameter i den generiska typen eller metoden. Den nullbara typen "type1" uppfyller inte villkorsbegränsningen.
• CS0313: Typen "type1" kan inte användas som typparameter i den generiska typen eller metoden. Den nullbara typen "type1" uppfyller inte villkorsbegränsningen. Nullbara typer kan inte uppfylla några gränssnittsbegränsningar.
• CS0314: Typen kan inte användas som typparameter i den generiska typen eller metoden. Det finns ingen boxningskonvertering eller typparameterkonvertering från "typ" till "begränsning".
• CS0315: Typen kan inte användas som typparameter T i den generiska typen eller metoden. Det finns ingen boxningskonvertering från "typ" till "begränsning".
• CS0401: Begränsningen new() måste vara den sista restriktiva begränsning som anges.
• CS0403: Det går inte att konvertera null till typparameter eftersom det kan vara en värdetyp som inte kan null. Överväg att använda default(T) i stället.
• CS0405: Duplicerad begränsning för typparameter.
• CS0406: Begränsningen för klasstyp, 'constraint', måste komma före alla andra begränsningar.
• CS0409: En begränsningssats har redan angetts för typparametern "type parameter". Alla begränsningar för en typparameter måste anges i en enda where-sats.
• CS0411: Typargumenten för metoden "method" kan inte härledas från användningen. Prova att uttryckligen ange typargumenten.
• CS0412: Parameter: en parameter, lokal variabel eller lokal funktion kan inte ha samma namn som en parameter av metodtyp.
• CS0413: Typparametern kan inte användas med operatorn as eftersom den inte har någon klasstypsbegränsning eller ett class villkor.
• CS0417: Identifierare: kan inte ange argument när du skapar en instans av en variabeltyp.
• CS0449: Begränsningarna class, struct, unmanaged, notnulloch default kan inte kombineras eller dupliceras, och måste anges först i begränsningslistan.
• CS0450: Typparameter: kan inte ange både en villkorsklass och villkoret class eller struct .
• CS0451: Begränsningen new() kan inte användas med begränsningen struct.
• CS0452: Typen "typnamn" måste vara en referenstyp för att kunna använda den som parametern "parameternamn" i den generiska typen eller metoden "generic".
• CS0453: Typen "typnamn" måste vara en värdetyp som inte kan nollställas för att kunna använda den som parametern "parameternamn" i den generiska typen eller metoden "generic".
• CS0454: Cirkulärt villkorsberoende med typparameter 1 och typparameter 2.
• CS0455: Typparametern ärver motstridiga villkor "constraint1" och "constraint2".
• CS0456: Typparametern "type parameter 1" har villkoret "struct" så "type parameter 1" kan inte användas som villkor för "type parameter 2".
• CS0693: Typparametern "type parameter" har samma namn som typparametern från den yttre typen "type".
• CS0694: Typparametern har samma namn som den innehållande typen eller metoden.
• CS0695: "type" kan inte implementera både "interface1" och "interface2" eftersom de kan förenas för vissa typparameterersättningar.
• CS0698: En allmän typ kan inte härledas från typen eftersom den är en attributklass.
• CS0699: "generic" definierar inte typparametern "identifierare".
• CS0701: "identifierare" är inte ett giltigt villkor. En typ som används som villkor måste vara ett gränssnitt, en icke-förseglad klass eller en typparameter.
• CS0702: Villkor får inte vara en särskild klass.
• CS0703: Inkonsekvent tillgänglighet: villkorstypen är mindre tillgänglig än deklarationen.
• CS0704: Det går inte att söka efter icke-virtuella medlemmar i "typ" eftersom det är en typparameter.
• CS0706: Ogiltig villkorstyp. En typ som används som villkor måste vara ett gränssnitt, en icke-förseglad klass eller en typparameter.
• CS0717: Statisk klass: Statiska klasser kan inte användas som begränsningar.
• CS0718: "type": statiska typer kan inte användas som typargument.
• CS1720: Uttrycket orsakar alltid en System.NullReferenceException eftersom standardvärdet för "generisk typ" är null.
• CS1763: "parametern" är av typen "typ". Ett standardparametervärde av en annan referenstyp än sträng kan bara initieras med null.
• CS1948: Intervallvariabeln "name" får inte ha samma namn som en metodtypparameter.
• CS1960: Ogiltig variansmodifierare. Endast gränssnitts- och ombudstypparametrar kan anges som variant.
• CS1961: Ogiltig varians: Typparametern måste vara covariant giltig för "typ". "type parameter" är kontravariant.
• CS3024: Villkorstypen "type" är inte CLS-kompatibel.
• CS7002: Oväntad användning av ett allmänt namn.
• CS8322: Det går inte att skicka argument med dynamisk typ till allmän lokal funktion med argument av härledd typ.
• CS8375: Begränsningen "new()" kan inte användas med begränsningen "unmanaged".
• CS8377: Typen "typ" måste vara en värdetyp som inte kan nollställas, tillsammans med alla fält på valfri kapslingsnivå, för att kunna använda den som parametern "parameter" i den generiska typen eller metoden "generic".
• CS8379: Typparametern "type parameter 1" har villkoret "ohanterad" så "typparameter 1" kan inte användas som villkor för "typparameter 2".
• CS8380: "type": kan inte ange både en begränsningsklass och villkoret "ohanterad".
• CS8387: Typparametern "type parameter" har samma namn som typparametern från den yttre metoden "method".
• CS8389: Det går inte att utelämna typargumentet i den aktuella kontexten.
• CS8427: Uppräkningar, klasser och strukturer kan inte deklareras i ett gränssnitt som har en parameter av typen "in" eller "out".
• CS8665: Metoden method anger en klassbegränsning för typparametern "type parameter", men motsvarande typparameter "type parameter" för den åsidosatta eller uttryckligen implementerade metoden "method" är inte en referenstyp.
• CS8666: Metoden "method" anger en "struct"-begränsning för typparametern "type parameter", men motsvarande typparameter "type parameter" för den åsidosatta eller uttryckligen implementerade metoden "method" är inte en värdetyp som inte kan nullvärde.
• CS8822: Metoden "metod" anger en "standardvillkor" för typparametern "type parameter", men motsvarande typparameter "type parameter" för den åsidosatta eller uttryckligen implementerade metoden "method" är begränsad till en referenstyp eller en värdetyp.
• CS8823: Standardvillkoret är endast giltigt för åsidosättning och explicita gränssnittsimplementeringsmetoder.
• CS8893: "type" är inte en giltig anropskonventionstyp för "UnmanagedCallersOnly".
• CS8894: Det går inte att använda "typ" som parameter eller returtyp på en metod som tillskrivs "UnmanagedCallersOnly".
• CS8895: Metoder som tillskrivs "UnmanagedCallersOnly" kan inte ha generiska typparametrar och kan inte deklareras i en generisk typ.
• CS8896: "UnmanagedCallersOnly" kan endast tillämpas på vanliga statiska icke-abstrakta, icke-virtuella metoder eller statiska lokala funktioner.
• CS9011: Nyckelord delegate kan inte användas som villkor. Menade System.Delegatedu det?
• CS9012: Oväntat nyckelord record. Menade record struct du eller record class?
• CS9338: Inkonsekvent åtkomsträttighet: typen har lägre åtkomst än klassen.

Typparameterdeklaration och namngivning

• CS0080: Begränsningar tillåts inte för icke-generiska deklarationer.
• CS0081: Typparameterdeklarationen måste vara en identifierare, inte en typ.
• CS0412: Parameter: en parameter, lokal variabel eller lokal funktion kan inte ha samma namn som en parameter av metodtyp.
• CS0693: Typparametern "type parameter" har samma namn som typparametern från den yttre typen "type".
• CS0694: Typparametern har samma namn som den innehållande typen eller metoden.
• CS0699: "generic" definierar inte typparametern "identifierare".
• CS1948: Intervallvariabeln "name" får inte ha samma namn som en metodtypparameter.
• CS8387: Typparametern "type parameter" har samma namn som typparametern från den yttre metoden "method".
• CS9012: Oväntat nyckelord record. Menade record struct du eller record class?

De här felen gäller hur du deklarerar och namnger typparametrar i generiska typer och metoder. Typparameternamn måste vara giltiga identifierare, får inte vara i konflikt med andra identifierare i omfånget och måste visas i deklarationens typparameterlista.

• Ta bort villkorssatsen från icke-generiska deklarationer (CS0080). where Satsen kan endast användas på generiska typer och metoder som deklarerar typparametrar. Om du behöver tillämpa begränsningar lägger du först till typparametrar i din typ- eller metoddeklaration.
• Ersätt faktiska typnamn med identifierare i typparameterdeklarationer (CS0081). Du måste deklarera typparametrar med hjälp av identifierare (till exempel T, TKeyeller TValue) i stället för betongtyper (t.exempel int eller string). Syftet med en typparameter är att fungera som en platshållare som kompilatorn ersätter med faktiska typer när den generiska typen eller metoden används.
• Byt namn på typparametrar, lokala variabler, parametrar eller intervallvariabler för att undvika namngivningskonflikter (CS0412, CS0694, CS1948). Typparameternamn kan inte skugga identifierare i samma omfång och de kan inte matcha namnet på den innehållande typen eller metoden. LINQ-intervallvariabler kan inte heller återanvända en metods typparameternamn. Sådana konflikter skapar tvetydighet om vilken identifierare som refereras.
• Använd ett annat namn för parametrar av inre typ som skuggar yttre parametrar (CS0693, CS8387). När en allmän medlem (till exempel en metod eller kapslad typ) finns i en generisk klass eller metod är parametern för den inre typen inte nödvändigtvis samma som den yttre. Att ge dem samma namn skapar förvirring om vilken typparameter som refereras. Använd ett distinkt namn för den inre typparametern.
• Se till att alla typparametrar i villkorssatser deklareras i typparameterlistan (CS0699). En where sats kan bara referera till typparametrar som visas i den allmänna deklarationen. Om namnet i where satsen inte matchar någon deklarerad typparameter söker du efter stavfel eller felstavningar.
• Använd rätt postdeklarationssyntax (CS9012). När du deklarerar en registertyp måste du använda antingen record class eller record struct (eller bara record för en referenstyp). Enbart nyckelordet record kan inte visas i positioner där kompilatorn förväntar sig en annan deklarationssyntax.

Mer information finns i Generiska typparametrar och generiska objekt.

Begränsningsdeklaration och ordningsföljd

• CS0401: Begränsningen new() måste vara den sista begränsningen som medför restriktioner som anges.
• CS0406: Klassbegränsningen 'constraint' måste komma före alla andra begränsningar.
• CS0409: En begränsningssats har redan angetts för typparametern "type parameter". Alla begränsningar för en typparameter måste anges i en enda where-sats.
• CS0449: Begränsningarna class, struct, unmanaged, notnulloch default kan inte kombineras eller dupliceras, och måste anges först i begränsningslistan.
• CS0450: Typparameter: kan inte ange både en villkorsklass och villkoret class eller struct .
• CS0451: Begränsningen new() kan inte användas med begränsningen struct.
• CS8375: Begränsningen ”new()” kan inte användas med begränsningen ”unmanaged”.
• CS8380: "type": kan inte ange både en begränsningsklass och villkoret "ohanterad".
• CS9011: Nyckelord delegate kan inte användas som villkor. Menade System.Delegatedu det?

Begränsningar för typparametrar måste följa en specifik ordning: primära begränsningar (class, , structunmanaged, notnull, eller default) kommer först, sedan en klasstypsbegränsning följt av gränssnittsbegränsningar och slutligen konstruktorbegränsningennew(). Vissa begränsningar är ömsesidigt uteslutande och kan inte kombineras. Alla begränsningar för en parameter av en enda typ måste visas i en enda sats where .

• Placera villkoret new() i slutet av begränsningslistan (CS0401). Villkoret new() måste visas efter alla andra begränsningar. Ändra where T : new(), IDisposable till exempel till where T : IDisposable, new().
• Placera klasstypsbegränsningen före gränssnittsbegränsningar (CS0406). När du begränsar en typparameter till en specifik basklass tillsammans med gränssnitt måste klassen visas först. Ändra where T : IDisposable, MyBaseClass till exempel till where T : MyBaseClass, IDisposable.
• Kombinera alla begränsningar för en typparameter till en enskild sats where (CS0409). Du kan inte använda flera where satser för samma typparameter. Sammanfoga dem i en sats: ändra where T : I where T : new() till where T : I, new(). Flera where satser är bara giltiga när de riktar in sig på olika typparametrar.
• Placera primära begränsningar först och kombinera inte ömsesidigt uteslutande begränsningar (CS0449). Du kan ange högst en av class, struct, unmanaged, notnulleller default, och den måste visas först i begränsningslistan. Begränsningarna class och struct är ömsesidigt uteslutande, liksom class och unmanaged.
• Kombinera inte en specifik klassbegränsning med class, structeller unmanaged (CS0450, CS8380). Om en typparameter är begränsad till en viss klasstyp är den implicit en referenstyp som strider mot villkoret struct eller unmanaged . Ta bort antingen klassvillkoret eller den primära begränsningen.
• Kombinera new() inte med struct eller unmanaged (CS0451, CS8375). Alla värdetyper har implicit en offentlig parameterlös konstruktor, så villkoret är redundant när det new() kombineras med struct. Detsamma gäller för unmanaged, vilket innebär struct. Ta bort villkoret new() .
• Ersätt delegate med System.Delegate i villkorssatser (CS9011). Nyckelordet delegate används för att deklarera ombudstyper, inte som en begränsning. Om du vill begränsa en typparameter till att delegera typer använder du System.Delegate som villkorstyp.

Mer information finns i Begränsningar för typparametrar.

Giltiga begränsningstyper

• CS0405: Duplicerad begränsning för typparameter.
• CS0701: "identifierare" är inte ett giltigt villkor. En typ som används som villkor måste vara ett gränssnitt, en icke-förseglad klass eller en typparameter.
• CS0702: Villkor får inte vara en särskild klass.
• CS0703: Inkonsekvent tillgänglighet: villkorstypen är mindre tillgänglig än deklarationen.
• CS0706: Ogiltig villkorstyp. En typ som används som villkor måste vara ett gränssnitt, en icke-förseglad klass eller en typparameter.
• CS0717: Statisk klass: Statiska klasser kan inte användas som begränsningar.
• CS3024: Villkorstypen "type" är inte CLS-kompatibel.

En begränsning måste vara ett gränssnitt, en icke-förseglad klass eller en typparameter. Vissa typer är ogiltiga som begränsningar på grund av deras särskilda betydelse i .NET-typsystemet eller på grund av att de inte kan ärvas.

• Ta bort duplicerade begränsningar (CS0405). Varje begränsning kan bara visas en gång i en begränsningssats. Om du har where T : I, Itar du bort dubbletten.
• Använd endast icke-förseglade typer som begränsningar (CS0701). Förseglade klasser, structs och uppräkningar kan inte ärvas, så de tjänar inget syfte som begränsningar. Använd ett gränssnitt som de önskade typerna implementerar eller använd en icke-förseglad basklass.
• Använd inte specialklasser som begränsningar (CS0702). Typerna Object, Arrayoch ValueType kan inte användas som begränsningar. Varje typ härleds redan från Object, så att begränsa till den ger inget värde. Array och ValueType är abstrakta bastyper som inte kan ärvas direkt. Om du behöver matrisliknande beteende, använd IList<T> eller IEnumerable<T> i stället.
• Se till att villkorstyperna är minst lika tillgängliga som den allmänna typen (CS0703). En offentlig allmän typ kan inte ha begränsningar med hjälp av interna typer, eftersom extern kod inte skulle kunna ange giltiga typargument. Gör antingen villkorstypen offentlig eller minska tillgängligheten för den allmänna typen.
• Använd endast gränssnitt, icke-förseglade klasser eller typparametrar som begränsningar (CS0706). Du kan inte använda matriser, förseglade klasser, structs, uppräkningar eller andra ogiltiga typer som begränsningar. Överväg att använda ett gränssnitt som de önskade typerna implementerar.
• Använd inte statiska klasser som begränsningar (CS0717). Statiska klasser kan inte utökas eftersom de bara innehåller statiska medlemmar. Ingen typ kan härledas från en statisk klass, vilket gör den värdelös som en begränsning.
• Använd en CLS-kompatibel typ för typvillkoret (CS3024). När en sammansättning är markerad med [assembly: CLSCompliant(true)]kan en icke-CLS-kompatibel typ som en allmän typbegränsning göra det omöjligt för kod som skrivits på vissa språk att använda den generiska klassen.

Mer information finns i Begränsningar för typparametrar.

Villkorsnöjdhet och konverteringar

• CS0311: Typen kan inte användas som typparameter T i den generiska typen eller metoden. Det finns ingen implicit referenskonvertering från "type1" till "type2".
• CS0312: Typen kan inte användas som typparameter i den generiska typen eller metoden. Den nullbara typen uppfyller inte villkorsbegränsningen.
• CS0313: Typen kan inte användas som typparameter i den generiska typen eller metoden. Den nullbara typen uppfyller inte villkorsbegränsningen. Nullbara typer kan inte uppfylla några gränssnittsbegränsningar.
• CS0314: Typen kan inte användas som typparameter i den generiska typen eller metoden. Det finns ingen boxningskonvertering eller typparameterkonvertering från 'typ' till 'begränsning'.
• CS0315: Typen kan inte användas som typparameter T i den generiska typen eller metoden. Det finns ingen boxningskonvertering från "typ" till "begränsning".
• CS0452: Typen "typnamn" måste vara en referenstyp för att kunna använda den som parametern "parameternamn" i den generiska typen eller metoden "generic".
• CS0453: Typen "typnamn" måste vara en värdetyp som inte kan nollställas för att kunna använda den som parametern "parameternamn" i den generiska typen eller metoden "generic".
• CS8377: Typen "typ" måste vara en värdetyp som inte kan nollställas, tillsammans med alla fält på valfri kapslingsnivå, för att kunna använda den som parametern "parameter" i den generiska typen eller metoden "generic".

Dessa fel uppstår när ett typargument inte uppfyller de begränsningar som deklarerats för en allmän typparameter. Typargumentet måste ha rätt konverteringar, arvsrelationer och strukturella egenskaper för att matcha alla begränsningar.

• Ändra typargumentet till ett argument som har en implicit referenskonvertering till villkorstypen (CS0311). När en typparameter har en begränsning som where T : BaseTypemåste alla typargument konverteras till BaseType genom en implicit referenskonvertering eller identitetskonvertering. Implicita numeriska konverteringar (till exempel från short till int) uppfyller inte allmänna typparameterbegränsningar.
• Använd icke-nullbara värdetyper eller ändra villkorstypen (CS0312, CS0313). Nullbara värdetyper (till exempel int?) skiljer sig från deras underliggande värdetyper och uppfyller inte samma villkor. Nullbara värdetyper kan inte uppfylla gränssnittsbegränsningar eftersom själva null-omslutningen inte implementerar gränssnittet. Använd den icke-nullbara formen av värdetypen som typargument.
• Upprepa begränsningarna för basklassens typparameter i en härledd klassdeklaration (CS0314). När en härledd generisk klass ärver från en begränsad generisk basklass måste den härledda klassen deklarera samma begränsningar för motsvarande typparametrar.
• Kontrollera att typargument uppfyller referenstyp- eller klassbegränsningar (CS0315). När en typparameter är begränsad till en klasstyp kan du inte använda en värdetyp (struct) som typargument eftersom det inte finns någon boxningskonvertering som uppfyller villkorsrelationen. Använd en referenstyp som ärver från eller implementerar villkoret.
• Använd en referenstyp som typargument när villkoret class anges (CS0452). Värdetyper som struct eller int kan inte uppfylla en class begränsning. Ändra antingen typargumentet till en referenstyp eller ta bort villkoret class om den allmänna typen kan fungera med värdetyper.
• Använd en värdetyp som inte är nullbar som typargument när villkoret struct anges (CS0453). Referenstyper, nullbara värdetyper (int?) och andra icke-värdetyper kan inte uppfylla en struct begränsning. Använd en konkret värdetyp som inte kan nulliseras, till exempel int, doubleeller en användardefinierad struct.
• Använd en typ vars fält alla är ohanterade typer när villkoret unmanaged anges (CS8377). Villkoret unmanaged kräver en icke-nullbar värdetyp där varje fält, på varje kapslingsnivå, också är en ohanterad typ. Typer som innehåller fält av referenstyp eller generiska typparametrar som inte är kända för att vara ohanterade uppfyller inte den här begränsningen.

Mer information finns i Begränsningar för typparametrar.

Begränsningskonflikter och cirkulära beroenden

• CS0454: Cirkulärt villkorsberoende med typparameter 1 och typparameter 2.
• CS0455: Typparametern ärver motstridiga villkor "constraint1" och "constraint2".
• CS0456: Typparametern "type parameter 1" har villkoret "struct" så "type parameter 1" kan inte användas som villkor för "type parameter 2".
• CS8379: Typparametern "type parameter 1" har villkoret "ohanterad" så "typparameter 1" kan inte användas som villkor för "typparameter 2".

Begränsningar kan inte skapa cirkulära beroenden och typparametrar kan inte ärva motstridiga begränsningar som är omöjliga att uppfylla samtidigt. Begränsningar för värdetyp (struct och unmanaged) är implicit förseglade, så de kan inte användas som begränsningar för andra typparametrar.

• Ta bort cirkulära villkorsberoenden (CS0454). En typparameter kan inte direkt eller indirekt vara beroende av sig själv genom sina begränsningar. Skapar till exempel where T : U where U : T ett cirkulärt beroende. Bryt cykeln genom att ta bort en av begränsningarna.
• Ta bort motstridiga ärvda begränsningar (CS0455). En typparameter kan inte begränsas till flera orelaterade klasser, eftersom C# inte stöder flera klassarv. På samma sätt kan den inte begränsas till både struct och en klasstyp. Omstrukturera din typhierarki eller ta bort någon av de motstridiga begränsningarna.
• Använd inte en struct-begränsad eller unmanaged-begränsad typparameter som villkor för en annan typparameter (CS0456, CS8379). Begränsningar för värdetyp är implicit förseglade, så ingen annan typ kan härledas från dem. Lös det här felet genom att placera värdetypen eller den ohanterade begränsningen direkt på den andra typparametern i stället för att indirekt begränsa den via den första typparametern.

Mer information finns i Begränsningar för typparametrar.

Regler för åsidosättning och implementeringsbegränsningar

• CS8665: Metoden method anger en klassbegränsning för typparametern "type parameter", men motsvarande typparameter "type parameter" för den åsidosatta eller uttryckligen implementerade metoden "method" är inte en referenstyp.
• CS8666: Metoden "method" anger en "struct"-begränsning för typparametern "type parameter", men motsvarande typparameter "type parameter" för den åsidosatta eller uttryckligen implementerade metoden "method" är inte en värdetyp som inte kan nullvärde.
• CS8822: Metoden "metod" anger en "standardvillkor" för typparametern "type parameter", men motsvarande typparameter "type parameter" för den åsidosatta eller uttryckligen implementerade metoden "method" är begränsad till en referenstyp eller en värdetyp.
• CS8823: Standardvillkoret är endast giltigt för åsidosättning och explicita gränssnittsimplementeringsmetoder.

När du åsidosätter en virtuell metod eller uttryckligen implementerar en gränssnittsmetod måste begränsningarna för den åsidosättande metodens typparametrar vara kompatibla med basmetodens begränsningar. Villkoret default är en särskild modifierare som endast används i scenarier för åsidosättning och explicit gränssnittsimplementering för att indikera att en typparameter varken har en class eller struct begränsning.

• Se till att den övergripande metodens begränsningar matchar basmetodens begränsningar (CS8665, CS8666). En åsidosättning kan inte lägga till en class begränsning om basmetodens motsvarande typparameter inte är begränsad till en referenstyp. På samma sätt kan den inte lägga till en struct begränsning om basmetodens typparameter inte är begränsad till en värdetyp. Åsidosättningen måste vara kompatibel med basdeklarationen.
• Använd villkoret default endast när basmetodens typparameter inte är tränad (CS8822). Villkoret default anger att typparametern inte har någon class eller struct begränsning. Du kan inte använda default om motsvarande typparameter för den åsidosatta metoden redan har en class- eller struct-begränsning.
• Använd begränsningen default endast för override-metoder eller metoder för explicit gränssnittsimplementering (CS8823). Villkoret default är inte giltigt för vanliga metoddeklarationer. Det finns specifikt för att undanröja tvetydighet när du åsidosätter en metod där basklassen hade en typparameter utan begränsningar, och du behöver ange att åsidosättningen också lämnar den utan begränsningar.

Mer information finns i Begränsningar för typparametrar och villkordefault.

Konstruktorbegränsningar

• CS0304: Det går inte att skapa en instans av variabeltypen eftersom den inte har villkoret new() .
• CS0310: Typen måste vara en icke-abstrakt typ med en offentlig parameterlös konstruktor för att kunna använda den som parameter i den generiska typen eller metoden.
• CS0417: Identifierare: kan inte ange argument när du skapar en instans av en variabeltyp.

Dessa fel gäller villkoret new() och instansiering av typparametrar med operatorn new .

• Lägg till villkoret new() för att skriva parametrar som du behöver instansiera (CS0304). När du använder new T() en allmän typ eller metod måste kompilatorn garantera att alla typargument har en parameterlös konstruktor. Villkoret new() ger den här garantin.
• Kontrollera att typargument har offentliga parameterlösa konstruktorer (CS0310). När en typparameter har villkoret new() måste alla konkreta typer som används som ett typargument vara icke-abstrakta och måste tillhandahålla en offentlig parameterlös konstruktor. Typer med endast privata, skyddade eller parametriserade konstruktorer kan inte uppfylla villkoret new() .
• Ta bort konstruktorargument när du instansierar typparametrar (CS0417). Begränsningen new() garanterar endast en parameterlös konstruktor. Du kan inte skicka argument till new T(arguments). Om du behöver skapa instanser med specifika argument kan du överväga att använda ett fabriksmönster eller en gränssnittsbegränsning som definierar byggbeteendet.

Mer information finns i Begränsningar för typparametrar och villkornew().

Ange antal argument och användning

• CS0224: En metod med vararg kan inte vara generisk, vara av allmän typ eller ha en params-parameter.
• CS0305: Användning av den allmänna typen kräver argument av N-typ.
• CS0306: Typen kanske inte används som ett typargument.
• CS0307: Identifieraren kan inte användas med typargument.
• CS0308: Den icke-generiska typen eller metoden kan inte användas med typargument.
• CS7002: Oväntad användning av ett allmänt namn.
• CS8389: Det går inte att utelämna typargumentet i den aktuella kontexten.

De här felen gäller att ange rätt antal och typ av argument till generiska typer och metoder.

• Ta bort generiska typparametrar eller som innehåller allmänna typdeklarationer från metoder som använder __arglist (CS0224). Nyckelordet __arglist är inte kompatibelt med generiska objekt eftersom körningsmekanismerna för hantering av variabelargumentlistor står i konflikt med den typersättning som krävs för generiska typparametrar.
• Ange det exakta antalet typargument som anges i den allmänna deklarationen (CS0305). Varje generisk typparameter i definitionen måste ha ett motsvarande typargument när den generiska typen instansieras.
• Använd endast giltiga typer som typargument (CS0306). Pekartyper (till exempel int* eller char*) kan inte användas som typargument eftersom allmänna typer kräver hanterade typer som skräpinsamlaren kan spåra.
• Ta bort typargumentsyntax från icke-generiska konstruktioner (CS0307, CS0308). Typargument som omges av vinkelparenteser kan endast tillämpas på generiska typer och metoder som deklarerar typparametrar. Kontrollera att du har importerat namnområdet som innehåller den allmänna versionen av typen.
• Ta bort typparametrar från deklarationer som inte stöder generiska objekt (CS7002). Vissa konstruktioner, till exempel uppräkningar, kan inte vara generiska. Om du behöver en allmän container för uppräkningsvärden bör du överväga att använda en allmän klass eller struct i stället.
• Ange alla obligatoriska typargument explicit (CS8389). I vissa sammanhang, till exempel att använda operatorn typeof eller skapa ombud, måste du ange alla typargument och inte utelämna dem. Använd till exempel typeof(List<int>) i stället för att försöka utelämna typargumentet.

Mer information finns i Generiska typparametrar och generiska objekt.

Skriv argumentinferens

• CS0411: Typargumenten för metoden "method" kan inte härledas från användningen. Prova att uttryckligen ange typargumenten.

Det här felet uppstår när du anropar en allmän metod utan att uttryckligen ange typargumenten och kompilatorn inte kan härleda vilka typargument du tänker använda. Kompilatorn härleder typargument från de typer av metodargument som du skickar till anropsplatsen.

• Ange typargumenten explicit inom vinkelparenteser (CS0411). Om kompilatorn inte kan fastställa typargumenten från metodargumenten anger du dem direkt. Ändra G() till exempel till G<int>(). Det här felet uppstår ofta när en generisk metod inte har några parametrar som du kan härleda typen från, eller när ett null argument skickas och kompilatorn inte kan fastställa den avsedda typen.

Mer information finns i Allmänna metoder.

Typparameteravvikelse

• CS1960: Ogiltig variansmodifierare. Endast gränssnitts- och ombudstypparametrar kan anges som variant.
• CS1961: Ogiltig varians: Typparametern måste vara covariant giltig för "typ". "type parameter" är kontravariant.
• CS8427: Uppräkningar, klasser och strukturer kan inte deklareras i ett gränssnitt som har en parameter av typen "in" eller "out".

Variansmodifierare (in för kontravariant out , för kovarians) styr hur du kan använda typparametrar i gränssnitts- och ombudsdeklarationer. Endast gränssnitt och ombud stöder varians. En parameter av typen covariant (out) kan bara visas i utdatapositioner (returtyper), medan en parameter av typen contravariant (in) endast kan visas i indatapositioner (parametertyper).

• Använd endast variansmodifierare för parametrar av gränssnitts- och ombudstyp (CS1960). Klasser, structs och andra typdeklarationer stöder inte variansmodifierare. Endast interface och delegate deklarationer kan använda in eller out på deras typparametrar.
• Använd out (covariant) för typparametrar som endast visas i returtyper och in (kontravariant) för typparametrar som endast visas i parametertyper (CS1961). Om typparametern måste visas i både indata- och utdatapositioner tar du bort variansmodifieraren.
• Deklarera inte uppräkningar, klasser eller strukturer i ett variantgränssnitt (CS8427). Kapslade typdeklarationer i ett gränssnitt som har in eller out typparametrar tillåts inte eftersom de kan bryta mot avvikelsesäkerhetsreglerna. Flytta den kapslade typen utanför gränssnittsdeklarationen.

Mer information finns i Covariance och Contravariance i Generics.

Användningsbegränsningar av allmän typ

• CS0403: Det går inte att konvertera null till typparameter eftersom det kan vara en värdetyp som inte kan null. Överväg att använda default(T) i stället.
• CS0413: Typparametern kan inte användas med operatorn as eftersom den inte har någon klasstypsbegränsning eller ett class villkor.
• CS0695: "type" kan inte implementera både "interface1" och "interface2" eftersom de kan förenas för vissa typparameterersättningar.
• CS0698: En allmän typ kan inte härledas från typen eftersom den är en attributklass.
• CS0704: Det går inte att söka efter icke-virtuella medlemmar i "typ" eftersom det är en typparameter.
• CS0718: "type": statiska typer kan inte användas som typargument.
• CS1720: Uttrycket orsakar alltid en System.NullReferenceException eftersom standardvärdet för "generisk typ" är null.
• CS1763: "parametern" är av typen "typ". Ett standardparametervärde av en annan referenstyp än sträng kan bara initieras med null.
• CS8322: Det går inte att skicka argument med dynamisk typ till allmän lokal funktion med argument av härledd typ.
• CS9338: Inkonsekvent tillgänglighet: typen är mindre tillgänglig än klassen.

Dessa fel gäller begränsningar för hur generiska typer och typparametrar kan användas i uttryck, arv och medlemsåtkomst.

• Ersätt null tilldelningar med default(T) eller lägg till en class begränsning (CS0403). När du tilldelar null till en icke-tränad typparameter kan kompilatorn inte garantera att typargumentet är en referenstyp. Använd default(T), som ger lämpligt standardvärde för alla typer, eller lägg till en class begränsning om du specifikt behöver semantik av referenstyp.
• Lägg till en class eller specifik typbegränsning när du använder operatorn as (CS0413). Operatorn as returnerar null om konverteringen misslyckas, men värdetyper kan inte vara null. Lägg till en class begränsning för att säkerställa att typparametern alltid är en referenstyp.
• Undvik att implementera samma allmänna gränssnitt flera gånger med typparametrar som kan förenas (CS0695). När en klass implementerar ett allmänt gränssnitt flera gånger med olika typparametrar (till exempel class G<T1, T2> : I<T1>, I<T2>), skulle instansiering med samma typ för båda parametrarna skapa en konflikt. Implementera gränssnittet bara en gång eller omstrukturera för att förhindra enande.
• Ta bort generiska typparametrar från attributklasser (CS0698). Det här felet skapas inte längre i de aktuella versionerna av C#, eftersom generiska attribut nu stöds.
• Använd den konkreta begränsningstypen i stället för typparametern för kapslad medlemsåtkomst (CS0704). Du kan inte komma åt kapslade typer eller icke-virtuella medlemmar via en typparameter. I stället T.InnerTypeför använder du den kända begränsningstypen direkt, till exempel BaseClass.InnerType.
• Använd inte statiska typer som typargument (CS0718). Statiska typer kan inte instansieras och kan inte användas som allmänna argument. Ta bort den statiska typen från det allmänna argumentet.
• Undvik att anropa instansmedlemmar när default(T)T är begränsad till en referenstyp (CS1720). När T har en class begränsning, default(T) är null, så att anropa instansmedlemmar på den genererar alltid en NullReferenceException. Lägg till en null-kontroll innan du anropar medlemmar eller omstrukturera koden för att undvika att använda default(T) direkt.
• Använd null som standardparametervärde för valfria parametrar vars typ är en referenstyp (CS1763). Om en allmän metod har en parameter av typen T och T är en referenstyp ersätter du default(U) med null eftersom valfria parameterstandardvärden måste vara kompileringskonstanter och default(T) inte åtgärdar det kravet.
• Ange uttryckligen typargument när du skickar dynamiska värden till allmänna lokala funktioner (CS8322). När du skickar ett dynamic argument till en allmän lokal funktion kan kompilatorn inte härleda argument. Ange uttryckligen typargumentet eller omvandla det dynamiska värdet.
• Kontrollera att typargument som används i offentliga eller skyddade signaturer är minst lika tillgängliga som medlemmen (CS9338). En offentlig allmän medlem måste använda typargument som är offentligt tillgängliga. Gör antingen typargumentet offentligt eller minska tillgängligheten för medlemmen.

Mer information finns i Begränsningar för typparametrar och standardvärdeuttryck.

UnmanagedCallersOnly begränsningar

• CS8893: "type" är inte en giltig anropskonventionstyp för "UnmanagedCallersOnly".
• CS8894: Det går inte att använda "typ" som parameter eller returtyp på en metod som tillskrivs "UnmanagedCallersOnly".
• CS8895: Metoder som tillskrivs "UnmanagedCallersOnly" kan inte ha generiska typparametrar och kan inte deklareras i en generisk typ.
• CS8896: "UnmanagedCallersOnly" kan endast tillämpas på vanliga statiska icke-abstrakta, icke-virtuella metoder eller statiska lokala funktioner.

Attributet UnmanagedCallersOnlyAttribute markerar metoder som ohanterad kod kan anropa. Dessa metoder har strikta krav eftersom körningsmiljön måste hantera övergången mellan hanterade och ohanterade anropskonventioner.

• Använd endast giltiga typer av UnmanagedCallersOnly anropskonventioner i attributet (CS8893). Egenskapen CallConvs för attributet accepterar endast identifierade anropande konventionstyper från System.Runtime.CompilerServices namnområdet.
• Använd endast blittable-typer som parameter- och returtyper (CS8894). Metoder som har markerats med UnmanagedCallersOnly kan inte använda hanterade typer (till exempel string eller object) som parameter- eller returtyper eftersom ohanterade anropare inte kan hantera skräpinsamlade referenser.
• Ta bort generiska typparametrar från UnmanagedCallersOnly metoder och deklarera dem inte i generiska typer (CS8895). Ohanterade anropskonventioner stöder inte generiska typer eftersom körningsmiljön inte kan fastställa rätt anropskonvention för generiska typsubstitutioner.
• Gäller UnmanagedCallersOnly endast vanliga statiska, icke-abstrakta, icke-virtuella metoder eller statiska lokala funktioner (CS8896). Instansmetoder, abstrakta metoder och virtuella metoder kan inte markeras med UnmanagedCallersOnly eftersom ohanterade anropare inte kan utföra de sändningsmekanismer som dessa metoder kräver.

Mer information finns i UnmanagedCallersOnlyAttribute.