mono 3.4.1 - en to ka translation catalogue (595 entries)

en: Cannot convert `{0}' to an expression tree of non-delegate type `{1}'
ka: '{0}'-ის გადაყვანა არადელეგატი ტიპის '{1}' გამოსახულების ხეში შეუძლებელია

en: Cannot convert `{0}' to non-delegate type `{1}'
ka: '{0}'-ის არადელეგატ ტიპში '{1}' გადაყვანა შეუძლებელია

en: Cannot convert `{0}' to delegate type `{1}' since there is a parameter mismatch
ka: '{0}'-ის დელეგატ ტიპში '{1}' გადაყვანა შეუძლებელია, რადგან პარამეტრი არ ემთხვევა

en: Delegate `{0}' does not take `{1}' arguments
ka: დელეგატი '{0}' არ იღებს '{1}' არგუმენტებს

en: Parameter `{0}' should not be declared with the `{1}' keyword
ka: პარამეტრი '{0}' არ უნდა იყოს აღწერილი საკვანძო სიტყვით '{1}'

en: Parameter `{0}' must be declared with the `{1}' keyword
ka: პარამეტრი '{0}' უნდა იყოს აღწერილი საკვანძო სიტყვით '{1}'

en: Parameter `{0}' is declared as type `{1}' but should be `{2}'
ka: პარამეტრი '{0}' აღწერილია ტიპით '{1}' მაგრამ უნდა იყოს '{2}'

en: Async lambda expressions cannot be converted to expression trees
ka: ასინქრონული ლამბდა გამოსახულებების გადაყვანა გამოსახულების ხეებში შეუძლებელია

en: An anonymous method cannot be converted to an expression tree
ka: ანონიმური მეთოდის გამოსახულების ხეში გადაყვანა შეუძლებელია

en: Cannot convert anonymous method block without a parameter list to delegate type `{0}' because it has one or more `out' parameters
ka: ანონიმური მეთოდის ბლოკის გადაყვანა პარამეტრების სიის დელეგატის ტიპში '{0}' შეუძლებელია, რადგან მას ერთი ან მეტი 'out' პარამეტრი გააჩნია

en: Anonymous methods and lambda expressions cannot be used in the current context
ka: ანონიმური მეთოდების და ლამბდა გამოსახულებების გამოყენება შეუძლებელია მიმდინარე კონტექსტში

en: Local variable or parameter `{0}' cannot have their address taken and be used inside an anonymous method, lambda expression or query expression
ka: ლოკალური ცვლადი ან პარამეტრი '{0}' ვერ აიღებს თავის მისამართს და ვერ გამოიყენებს ანონიმური მეთოდის, ლამბდა გამოსახულების ან გამოთხოვის გამოახულების შიგნით

en: Cannot convert async {0} to delegate type `{1}'
ka: ასინქრონული {0}-ის დელეგატის ტიპში '{1}' გადაყვანა შეუძლებელია

en: An expression tree cannot contain an anonymous method expression
ka: გამოსახულებების ხე, არ შეიძლება, ანონიმური მეთოდის გამოსახულებას შეიცავდეს

en: `{0}': An anonymous type cannot have multiple properties with the same name
ka: '{0}': ანონიმურ ტიპს იგივე სახელის მქონე ერთზე მეტი თვისება ვერ ექნება

en: An expression tree cannot contain an invocation which uses optional parameter
ka: გამოსახულებების ხე არ შეიძლება შეიცავდეს ჩაწოდებას, რომელიც არასავალდებულო პარამეტრს იყენებს

en: An expression tree cannot contain named argument
ka: გამოსახულებების ხე, არ შეიძლება, სახელიან არგუმენტს შეიცავდეს

en: The method group `{0}' cannot be used as an argument of dynamic operation. Consider using parentheses to invoke the method
ka: მეთოდების ჯგუფს '{0}' დინამიკური ოპერაციის არგუმენტად ვერ გამოიყენებთ. მეთოდის ჩასაწოდებლად ფრჩხილები გამოიყენეთ

en: An anonymous method or lambda expression cannot be used as an argument of dynamic operation. Consider using a cast
ka: ანონიმურ მეთოდს ან ლამბდა გამოსახულებას დინამიკური ოპერაციის არგუმენტად ვერ გამოიყენებთ. გამოიყენეთ გადაყვანა

en: An expression of type `{0}' cannot be used as an argument of dynamic operation
ka: გამოსახულებას ტიპით '{0}' დინამიკური ოპერაციის არგუმენტად ვერ გამოიყენებთ

en: An expression tree cannot contain an assignment operator
ka: გამოსახულებების ხე არ შეიძლება, მინიჭების ოპერატორს შეიცავდეს

en: Cannot assign to `{0}' because it is a `{1}'
ka: შეუძლებელია '{0}'-ზე მინიჭება რადგან ის '{1}'-ია

en: Invalid type specified as an argument for TypeForwardedTo attribute
ka: TypeForwardTo ატრიბუტისთვის მითითებული არგუმენტის ტიპი არასწორია

en: A duplicate type forward of type `{0}'
ka: გამეორებული ტიპის გადაგზავნა ტიპისთვის '{0}'

en: Cannot forward type `{0}' because it is defined in this assembly
ka: ტიპის '{0}' გადაგზავნა შეუძლებელია, რადგან ის აღწერილია ამ ანაწყობში

en: Cannot forward type `{0}' because it is a nested type
ka: ტიპის '{0}' გადაგზავნა შეუძლებელია, რადგან ის ერთმანეთშია ჩალაგებული

en: Friend assembly reference `{0}' is invalid. InternalsVisibleTo declarations cannot have a version, culture or processor architecture specified
ka: მეგობარი ანაწყობის მიმართვა '{0}' არასწორია. აღწერებს InternalsVisibleTo ვერსია, კულტურა ან პროცესორის არქიტექტურა მითითებული ვერ ექნება

en: Friend assembly reference `{0}' is invalid. Strong named assemblies must specify a public key in their InternalsVisibleTo declarations
ka: მეგობარი ანაწყობის მიმართვა '{0}' არასწორია. ძლიერი სახელიანი ანაწყობები თავიანთ InternalsVisitbleTo აღწერებში საჯარო გასაღებებს უნდა უთითებდნენ

en: Referenced assembly `{0}' does not have a strong name
ka: მიმართულ ანაწყობს '{0}' ძლიერი სახელი არ გააჩნია

en: Referenced assembly `{0}' has different culture setting of `{1}'
ka: მიმართულ ანაწყობს '{0}' აქვს '{1}'-ის განსხვავებული კულტურის პარამეტრი

en: Friend access was granted to `{0}', but the output assembly is named `{1}'. Try adding a reference to `{0}' or change the output assembly name to match it
ka: მეგობრის წვდომა მინიჭებულია '{0}'-სთვის, მაგრამ გამოტანილი ანაწყობის სახელია '{1}'. სცადეთ, '{0}'-ზე მიმართვა დაამატოთ, ან შეცვალეთ გამოტანილი ანაწყობის სახელი, რომ მას დაემთხვეს

en: Could not sign the assembly. ECMA key can only be used to delay-sign assemblies
ka: ანაწყობის ხელმოწერა შეუძლებელია. ECMA გასაღებს ანაწყობებისთვის, მხოლოდ, დაყოვნებული ხელმოწერისთვის თუ გამოიყენებთ

en: Added modules must be marked with the CLSCompliant attribute to match the assembly
ka: დამატებითი მოდულები CLSCompliant ატრიბუტით უნდა იყო დანიშნული, რომ ანაწყობს ემთხვეოდეს

en: Option `{0}' overrides attribute `{1}' given in a source file or added module
ka: პარამეტრი '{0}' გადაფარავს ატრიბუტს '{1}' მითითებულ კოდის ფაილში ან დამატებულ მოდულში

en: Delay signing was requested but no key file was given
ka: მოთხოვნილია დაყოვნებული ხელმოწერა, მაგრამ გასაღებს ფაილი მითითებული არაა

en: Cannot link resource file when building a module
ka: რესურსების ფაილის მიბმა შეუძლებელია მოდულის აგებისას

en: Error reading resource file `{0}'
ka: წაკითხვის შეცდომა რესურსის ფაილისთვის '{0}'

en: Cannot specify -main if building a module or library
ka: მოდულის ან ბიბლიოთეკის აგებისას -main-ს ვერ მიუთითებთ

en: Could not find `{0}' specified for Main method
ka: მეთოდისთვის Main მითითებული '{0}' ვიპოვე

en: `{0}' specified for Main method must be a valid class or struct
ka: მითითებული`{0}' მეთოდისთვის Main სწორი კლასი ან სტრუქტურა უნდა იყოს

en: `{0}' does not have a suitable static Main method
ka: `{0}'-ს შესაბამისი სტატიკური მეთოდი Main არ გააჩნია

en: Program `{0}' does not contain a static `Main' method suitable for an entry point
ka: პროგრამა '{0}' სტატიკურ მეთოდს 'Main', გამოსადეგს გაშვებისთვის, არ შეიცავს

en: Error during assembly signing.
ka: შეცდომა ანაწყობზე ხელმოწერისას.

en: Metadata file `{0}' could not be found
ka: მეტამონაცემების ფაილი '{0}' ვერ ვიპოვე

en: Metadata file `{0}' does not contain valid metadata
ka: მეტამონაცემების ფაილი '{0}' სწორ მეტამონაცემებს არ შეიცავს

en: Referenced assembly file `{0}' is a module. Consider using `-addmodule' option to add the module
ka: მიმართვის ანაწყობის ფაილი '{0}' მოდულია. მოდულის დასამატებლად '-addmodule' პარამეტრი გამოიყენეთ

en: Added module file `{0}' is an assembly. Consider using `-r' option to reference the file
ka: დამატებული მოდულის ფაილი '{0}' ანაწყობია. მის მაგიერ '-r' პარამეტრი გამოიყენეთ მიმართვის ფაილზე

en: The `await' operator cannot be used in the body of a lock statement
ka: ოპერატორს 'await' დაბლოკვის გამოსახულების სხეულში ვერ გამოიყენებთ

en: The `await' operator cannot be used in an unsafe context
ka: ოპერატორს 'await' სახიფათო კონტექსტში ვერ გამოიყენებთ

en: Cannot await void method `{0}'. Consider changing method return type to `Task'
ka: ყრუ მეთოდს '{0}' ვერ დაველოდები. სჯობს მეთოდის დაბრუნების ტიპი 'Task'-ზე შეცვალოთ

en: Cannot await `{0}' expression
ka: გამოსახულებას '{0}' ვერ დაველოდები

en: The awaiter type `{0}' must have suitable IsCompleted and GetResult members
ka: მომლოდინე ტიპს '{0} შესაბამისი IsCompleted და GetResult წევრები უნდა ჰქონდეს

en: The `await' operator may only be used in a query expression within the first collection expression of the initial `from' clause or within the collection expression of a `join' clause
ka: ოპერატორის 'await' გამოყენება, მხოლოდ, საწყისი 'from' პირობის პირველი კოლექციის გამოსახულებაში არსებულ მოთხოვნის გამოსახულებაში, ან 'join' პირობის კოლექციის გამოსახულებაში შეიძლება

en: The `await' operand type `{0}' must have suitable GetAwaiter method
ka: 'await' ოპერანდის ტიპს '{0}' შესაბამისი GetAwaiter მეთოდი უნდა ჰქონდეს

en: The awaiter type `{0}' must implement interface `{1}'
ka: მომლოდინე ტიპს '{0}' უნდა ჰქონდეს ინტერფეისი '{1}'

en: Cannot find compiler required types for asynchronous functions support. Are you targeting the wrong framework version?
ka: ასინქრონული ფუნქციების მხარდაჭერისთვის აუცილებელი კომპილატორის ტიპები აღმოჩენილი არაა. დარწმუნებული ბრძანდებით, რომ მითითებული პროგრამების გარემოს ვერსია სწორია?

en: `{0}' is not a valid named attribute argument. Named attribute arguments must be fields which are not readonly, static, const or read-write properties which are public and not static
ka: '{0}' არასწორი სახელიანი ატრიბუტის არგუმენტია. სახელიანი ატრიბუტის არგუმენტები უნდა იყოს ველები, რომლებიც არაა readonly, static, const ან read-write თვისებები, რომლებიც საჯადო და არასტატიკურია

en: `{0}' is not a valid named attribute argument because it is not a valid attribute parameter type
ka: '{0}' არასწორი სახელიანი ატრიბუტის არგუმენტია, რადგან ის სწორი ატრიბუტის პარამეტრის ტიპი არაა

en: An attribute argument cannot be dynamic expression
ka: ატრიბუტის არგუმენტი დინამიკური გამოსახულება ვერ იქნება

en: The Guid attribute must be specified with the ComImport attribute
ka: CommImport ატრიბუტთან ერთად Guid ატრიბუტი უნდა მიუთითოთ

en: Do not use `{0}' directly. Use parameter modifier `this' instead
ka: '{0}'-ს პირდაპირ ნუ გამოიყენებთ. ამისთვის გამოიყენეთ პარამეტრის მოდიფიკატორი 'this'

en: Do not use `{0}' directly. Use `dynamic' keyword instead
ka: '{0}'-ს პირდაპირ ნუ გამოიყენებთ. ამისთვის გამოიყენეთ საკვანძო სიტყვა 'dynamic'

en: Error during emitting `{0}' attribute. The reason is `{1}'
ka: '{0}' ატრიბუტის გამოცემის შეცდომა. მიზეზია: '{1}'

en: Invalid value for argument to `{0}' attribute
ka: არასწორი მნიშვნელობა არგუმენტისთვის '{0}' ატრიბუტში

en: `{0}' is ambiguous between `{1}' and `{2}'. Use either `@{0}' or `{0}Attribute'
ka: '{0} გაურკვეველია '{1}-სა და '{2}-ს შორის. გამოიყენეთ ან '@{0}', ან '{0}Attribute'

en: `{0}': is not an attribute class
ka: `{0}': ატრიბუტის კლასი არაა

en: Cannot apply attribute class `{0}' because it is abstract
ka: ატრიბუტის კლასს '{0}' ვერ გადაატარებთ, რადგან ის აბსტრაქტულია

en: Duplicate named attribute `{0}' argument
ka: გამეორებული სახელიანი ატრიბუტის '{0}' არგუმენტი

en: The attribute `{0}' is not valid on this declaration type. It is valid on `{1}' declarations only
ka: ატრიბუტი '{0}' არასწორია ამ აღწერის ტიპზე. ის, მხოლოდ, '{1}' გამოცხადებებზეა სწორი

en: The argument to the `{0}' attribute must be a valid identifier
ka: ატრიბუტის '{0}' არგუმენტი სწორი იდენტიფიკატორი უნდა იყოს

en: The attribute `{0}' cannot be applied multiple times
ka: ატრიბუტს '{0}' ერთზე მეტჯერ ვერ გადაატარებთ

en: `{0}' is obsolete: `{1}'
ka: `{0}' მოძველებულია: `{1}'

en: The `partial' modifier can be used only immediately before `class', `struct', `interface', or `void' keyword
ka: მოდიფიკატორი 'partial', შეიძლება, მხოლოდ, პირდაპირ 'class', 'struct', 'interface' ან 'void' საკვანძო სიტყვებამდე გამოიყენოთ

en: Unrecognized escape sequence `\{0}'
ka: უცნობი სპეციალური სიმბოლო `\{0}'

en: Unrecognized escape sequence
ka: უცნობი სპეციალური სიმბოლო

en: Filename, single-line comment or end-of-line expected
ka: მოველოდი ფაილის სახელს, ერთხაზიან კომენტარს ან ხაზის ბოლოს

en: Missing identifier to pre-processor directive
ka: პრეპროცესორის დირექტივას იდენტიფიკატორი აკლია

en: Identifier expected: {0}
ka: მოელოდი იდენტიფიკატორს: {0}

en: Integral constant is too large
ka: ინტეგრალური მუდმივა მეტისმეტად დიდია

en: Invalid number
ka: არასწორი ნომერი

en: Invalid preprocessor directive
ka: არასწორი პრეპროცესორის დირექტივა

en: Unexpected processor directive ({0})
ka: მოულოდნელი პროცესორის დირექტივა ({0})

en: Cannot define or undefine preprocessor symbols after first token in file
ka: პრეპროცესორის სიმბოლოების აღწერა ან აღწერის გაუქმება შეუძლებელია ფაილში პირველი ტოკენის შემდეგ

en: Preprocessor directives must appear as the first non-whitespace character on a line
ka: პრეპროცესორის დირექტივები ხაზის პირველი არა-ჰარე სიმბოლო უნდა იყოს

en: Single-line comment or end-of-line expected
ka: მოველოდი ერთხაზიან კომენტარს ან ხაზის ბოლოს

en: Expected `#endif' directive
ka: მოველოდი '#endif' დირექტივას

en: #endregion directive expected
ka: მოველოდი #endregion დირექტივას

en: Wrong preprocessor directive
ka: არასწორი პრეპროცესორის დირექტივა

en: #error: '{0}'
ka: #შეცდომა: '{0}'

en: The line number specified for #line directive is missing or invalid
ka: ხაზის ნომერი, რომელიც მითითებულია დირექტივაში #line, არ არსებობს ან არასწორია

en: Newline in constant
ka: ახალი ხაზი მუდმივაში

en: Unterminated string literal
ka: გაწყვეტილი ბიტური სტრიქონი

en: Identifier too long (limit is 512 chars)
ka: იდენტიფიკატორი მეტისმეტად გრძელია (მაქს 512 სიმბოლო)

en: End-of-file found, '*/' expected
ka: მოველოდი ფაილის ბოლოს. მოველოდი - '*/'-ს

en: Keyword, identifier, or string expected after verbatim specifier: @
ka: მოველოდი საკვანძო სიტყვას, იდენტიფიკატორს ან სტრიქონს ზუსტი ასლის მიმთითებლის შემდეგ: @

en: Unexpected character `{0}'
ka: მოულოდნელი სიმბოლო '{0}'

en: Empty character literal
ka: ცარიელი სიმბოლური მუდმივა

en: Too many characters in character literal
ka: მეტისმეტად ბევრი სიმბოლო იმბოლოს ასოითში

en: The operation overflows at compile time in checked mode
ka: ოპერაციის გადავსება კომპილაციისას შემოწმებულ რეჟიმში

en: Operator `{0}' is ambiguous on operands of type `{1}' and `{2}'
ka: ოპერატორი '{0}' ბუნდოვანია ოპერანდებზე ტიპებით '{1}' და '{2}'

en: Division by constant zero
ka: მუდმივას გაყოფა ნულზე

en: Partial declarations of `{0}' must be all classes, all structs or all interfaces
ka: '{0}' ის ნაწილობრივი აღწერები, ყველა ან კლასები უნდა იყოს, ან სტრუქტურები, ან ინტერფეისები

en: Partial declarations of `{0}' have conflicting accessibility modifiers
ka: '{0}'-ის ნაწილობრივ აღწერას უერთიერთგამომრიცხავი წვდომადობის მოდიფიკატორების გააჩნია

en: Partial declarations of `{0}' must have the same type parameter names in the same order
ka: '{0}'-ის ნაწილობრივ აღწერას იგივე ტიპის პარამეტრის სახელები უნდა ჰქონდეს, იგივე მიმდევრობით

en: Partial declarations of `{0}' must have the same type parameter variance modifiers
ka: '{0}'-ის ნაწილობრივ აღწერას იგივე ტიპის პარამეტრის ვარიაციის მოდიფიკატორების უნდა ჰქონდეს

en: Missing partial modifier on declaration of type `{0}'. Another partial declaration of this type exists
ka: ტიპს '{0}' აღწერისას ნაწილობრივი მოდიფიკატორი აკლია. არსებობს ამ ტიპის სხვა ნაწილობრივი აღწერა

en: `{0}': explicit interface declaration can only be declared in a class or struct
ka: `{0}': აშკარა ინტერფეისის გამოცხადება, მხოლოდ, კლასში ან სტრუქტურაშია შესაძლებელი

en: Duplicate type parameter `{0}'
ka: გამეორებული ტიპის პარამეტრი '{0}'

en: The type `{0}' already contains a definition for `{1}'
ka: ტიპი '{0}' უკვე შეიცავს აღწერას '{1}'-სთვის

en: Cannot specify the `DefaultMember' attribute on type containing an indexer
ka: ტიპზე, რომელიც ინდექსერს შეიცავს, ატრიბუტს 'DefaultMember' ვერ მიუთითებთ

en: The RequiredAttribute attribute is not permitted on C# types
ka: ატრიბუტი RequiredAttribute დაუშვებელია C#-ის ტიპებზე

en: Class `{0}' cannot derive from the dynamic type
ka: კლასი `{0}' დინამიკურ ტიპიდან მიღებული ვერ იქნება

en: `{0}' is already listed in interface list
ka: `{0}' უკვე არსებობს ინტერფეისების სიაში

en: Inconsistent accessibility: base interface `{0}' is less accessible than interface `{1}'
ka: არამდგრადი წვდომადობა: საბაზისო ინტერფეისი '{0}' ნაკლებად წვდომადია, ვიდრე ინტერფეისი '{1}'

en: Type `{0}' in interface list is not an interface
ka: ტიპი `{0}' ინტერფეისების სიაში ინტერფეისი არაა

en: `{0}': Classes cannot have multiple base classes (`{1}' and `{2}')
ka: `{0}': კლასებს ერთზე მეტი საბაზისო კლასი ვერ ექნება (`{1}' და `{2}')

en: `{0}': Base class `{1}' must be specified as first
ka: `{0}': საბაზისო კლასი `{1}' პირველი უნდა იყოს მითითებული

en: The operator `{0}' requires a matching operator `{1}' to also be defined
ka: ოპერატორს '{0}' დამთხვეული ოპერატორის '{1}' აღწერაც სჭირდება

en: Partial declarations of `{0}' must not specify different base classes
ka: '{0}'-ის ნაწილობრივი აღწერა არ უნდა მიუთითებდეს სხვა საბაზისო კლასებზე

en: Only one part of a partial type can declare primary constructor parameters
ka: ძირითადი კონსტრუქტორი პარამეტრების აღწერა ნაწილობრივი ტიპის, მხოლოდ, ერთ ნაწილს შეუძლია

en: Inherited interface `{0}' causes a cycle in the interface hierarchy of `{1}'
ka: მემკვიდრეობით მიღებული ინტერფეისი '{0}' იწვევს ჩაციკვლას '{1}'-ის ინტერფეისის იერარქიაში

en: Circular base class dependency involving `{0}' and `{1}'
ka: წრიული საბაზისო კლასის დამოკიდებულება, რომელიც '{0}'-სა და '{1}'-ს ეხება

en: `{0}': cannot implement a dynamic interface `{1}'
ka: `{0}': ვერ განვახორციელე დინამიკური ინტერფეისი `{1}'

en: `{0}' cannot implement both `{1}' and `{2}' because they may unify for some type parameter substitutions
ka: `{0}' ორივეს, `{1}' და `{2}' განხორცელება შეუძლებელია, რადგან ისინი, შეიძლება გაერთოანდნენ რომელიმე ტიპის პარამეტრის ჩასანაცვლებლად

en: A generic type cannot derive from `{0}' because it is an attribute class
ka: ზოგად ტიპს ვერ მიიღებთ '{0}'-დან, რადგან ის ატრიბუტის კლასია

en: Two indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type
ka: ორ ინდექსერს სხვადასხვა სახელები აქვთ. ტიპის შიგნით ატრიბუტი IndexerName იგივე სახელით უნდა გამოიყენოთ

en: A static member `{0}' cannot be marked as override, virtual or abstract
ka: სტატიკური წევრი '{0}' ვერ იქნება მონიშნული როგორც override, virtual ან abstract

en: A member `{0}' marked as override cannot be marked as new or virtual
ka: წევრი '{0}', მონიშნული, როგორც override, ვერ იქნება მონიშნული როგორც new ან virtual

en: `{0}' cannot be both extern and abstract
ka: `{0}' ორივე, extern და abstract ვერ იქნება

en: `{0}' cannot be both abstract and sealed
ka: `{0}' ორივე abstract და sealed ვერ იქნება

en: The abstract method `{0}' cannot be marked virtual
ka: აბსტრაქტულ მეთოდს '{0}' ვირტუალურად ვერ დანიშნავთ

en: `{0}' is abstract but it is declared in the non-abstract class `{1}'
ka: '{0}' აბსტრაქტულია, მაგრამ აღწერილია არააბსტრაქტულ კლასში '{1}'

en: `{0}': virtual or abstract members cannot be private
ka: `{0}': ვირტუალური ან აბსტრაქტული წევრები პირადი ვერ იქნება

en: `{0}' cannot be sealed because it is not an override
ka: `{0}' დაბეჭდილი ვერ იქნება, რადგან ის გადაფარვა არაა

en: `{0}': containing type does not implement interface `{1}'
ka: `{0}': შემცველი ტიპი არ ახორციელებს ინტერფეისს `{1}'

en: Type parameter `{0}' has same name as containing type, or method
ka: ტიპის პარამეტრს '{0}' გააჩნია იგივე სახელი, რაც შემცველ ტიპს, ან მეთოდს

en: `{0}': member names cannot be the same as their enclosing type
ka: `{0}': წევრის სახელები ვერ იქნება იგივე, რაც ტიპი, რომელშიც ისინია ჩასმული

en: Primary constructor of type `{0}' has parameter of same name as containing type
ka: ტიპის '{0}' ძირითად კონსტრუქტორს აქვს იგივე სახელი, რაც ტიპს, რომელსაც ის შეიცავს

en: Primary constructor of type `{0}' has parameter of same name as type parameter `{1}'
ka: ტიპის '{0}' ძირითად კონსტრუქტორს აქვს იგივე სახელი, რაც ტიპის პარამეტრს '{1}'

en: The class System.Object cannot have a base class or implement an interface.
ka: კლასს System.Object საბაზისო კლასი ვერ ექნება და ინტერფეისს ვერ განახორციელებს.

en: Attribute `{0}' is only valid on classes derived from System.Attribute
ka: ატრიბუტი '{0}', მხოლოდ, System.Attribute-დან მიღებულ კლასებზეა სწორი

en: Attribute `System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes
ka: ატრიბუტი `System.Diagnostics.ConditionalAttribute', მხოლოდ, მეთოდებზე ან ატრიბუტის კლასებზეა სწორი

en: `{0}': an abstract class cannot be sealed or static
ka: `{0}': აბსტრაქტული კლასი ბეჭდის მქონე ან სტატიკური ვერ იქნება

en: `{0}': a class cannot be both static and sealed
ka: `{0}': კლასი ორივე, სტატიკური და ბეჭდის მქონე ვერ იქნება

en: `{0}': Static classes cannot have primary constructor
ka: `{0}': სტატიკურ კლასებს ძირითადი კონსტრუქტორი ვერ ექნება

en: `{0}': Static classes cannot contain user-defined operators
ka: `{0}': სტატიკურ კლასები არ შეიძლება, მომხმარებლის მიერ აღწერილ ოპერატორებს შეიცავნენ

en: `{0}': Static classes cannot contain destructor
ka: `{0}': სტატიკურ კლასები არ შეიძლება, დესტრუქტორს სეიცავდეს

en: `{0}': cannot declare indexers in a static class
ka: `{0}': სტატიკურ კლასში ინდექსერებს ვერ აღწერთ

en: `{0}': Static classes cannot have instance constructors
ka: `{0}': სტატიკურ კლასებს არ შეიძლება, გაშვებული ასლის კონსტრუქტორები ჰქონდეს

en: `{0}': cannot declare instance members in a static class
ka: `{0}': გაშვებულ ასლის წევრებს სტატიკურ კლასში ვერ აღწერთ

en: `{0}': Cannot derive from type parameter `{1}'
ka: `{0}': ვერ მივიღე ტიპის პარამეტრიდან `{1}'

en: `{0}': Cannot derive from static class `{1}'
ka: `{0}': ვერ მივიღე სტატიკური კლასიდან `{1}'

en: `{0}': cannot derive from sealed type `{1}'
ka: `{0}': ვერ მივიღე ბეჭდის მქონე ტიპიდან `{1}'

en: Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object
ka: სტატიკურ კლასს '{0}' ტიპიდან '{1}' ვერ მიიღებთ. სტატიკური კლასები ობიექტიდან უნდა მიიღოთ

en: `{0}' cannot derive from special class `{1}'
ka: `{0}' ვერ მივიღე სპეციალური კლასიდან `{1}'

en: Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'
ka: არამდგრადი წვდომადობა: საბაზისო კლასი '{0}' ნაკლებად წვდომადია, ვიდრე კლასი '{1}'

en: Static class `{0}' cannot implement interfaces
ka: სტატიკურ კლასს '{0}' ინტერფეისების განხორციელება არ შეუძლია

en: Struct member `{0}' of type `{1}' causes a cycle in the struct layout
ka: სტრუქტურის წევრი '{0}' ტიპით '{1}' სტრუქტურის განლაგებაში ციკლურობას იწვევს

en: Do not override `{0}'. Use destructor syntax instead
ka: არ გადაფარო '{0}'. სამაგიეროდ დესტრუქტორის სინტაქსის გამოყენება შეგიძლიათ

en: `{0}' is marked as an override but no suitable {1} found to override
ka: '{0}' გადაფარვადაა მონიშნული, მაგრამ შესაბამისი {1} გადასაფარად ვერ ვიპოვე

en: `{0}': cannot override because `{1}' is not an event
ka: `{0}': `{1}'-ის გადაფარვა შეუძლებელია, რადგან ის მოვლენა არაა

en: `{0}': cannot override because `{1}' is not a property
ka: `{0}': `{1}'-ის გადაფარვა შეუძლებელია, რადგან ის თვისება არაა

en: `{0}': cannot override because `{1}' is not a method
ka: `{0}': `{1}'-ის გადაფარვა შეუძლებელია, რადგან ის მეთოდი არაა

en: `{0}' cannot override inherited members `{1}' and `{2}' because they have the same signature when used in type `{3}'
ka: `{0}' ვერ გადაფარავთ მემკვიდრეობით წევრებს `{1}' და `{2}', რადგან მათ იგივე ხელმოწერა აქვთ, როცა იყენებენ ტიპში `{3}'

en: `{0}' hides inherited abstract member `{1}'
ka: `{0}' მალავს მემკვიდრეობით მიღებულ აბსტრაქტულ წევრს `{1}'

en: `{0}': cannot override inherited member `{1}' because it is not marked virtual, abstract or override
ka: `{0}': ვერ გადაფარავთ მემკვიდრეობით წევრს `{1}', რადგან ის დანიშნული არაა საკვანძო სიტყვებით virtual, abstract, ან override

en: `{0}': cannot override inherited member `{1}' because it is sealed
ka: `{0}': ვერ გადავფარავ მემკვიდრეობით წევრს `{1}', რადგან ს დაბეჭდილია

en: `{0}': type must be `{1}' to match overridden member `{2}'
ka: `{0}': ტიპი უნდა იყოს `{1}' რომ ემთხვეოდეს გადაფარულ წევრს `{2}'

en: `{0}': return type must be `{1}' to match overridden member `{2}'
ka: `{0}': დაბრუნების ტიპი უნდა იყოს `{1}' რომ ემთხვეოდეს გადაფარულ წევრს `{2}'

en: A partial method `{0}' cannot explicitly implement an interface
ka: ნაწილობრივ მეთოდს '{0}' აშკრად ინტერფეისის განხორციელება არ შეუძლია

en: The type `{0}' in explicit interface declaration is not an interface
ka: ტიპი '{0}' აშკარა ინტერფეისის აღწერაში ინტერფეისი არაა

en: Inconsistent accessibility: parameter type `{0}' is less accessible than indexer `{1}'
ka: არამდგრადი წვდომადობა: პარამეტრის ტიპი '{0}' ნაკლებად წვდომადია, ვიდრე ინდექსერი '{1}'

en: Inconsistent accessibility: parameter type `{0}' is less accessible than operator `{1}'
ka: არამდგრადი წვდომადობა: პარამეტრის ტიპი '{0}' ნაკლებად წვდომადია, ვიდრე ოპერატორი '{1}'

en: Inconsistent accessibility: parameter type `{0}' is less accessible than method `{1}'
ka: არამდგრადი წვდომადობა: პარამეტრის ტიპი '{0}' ნაკლებად წვდომადია, ვიდრე მეთოდი '{1}'

en: `{0}': cannot change access modifiers when overriding `{1}' inherited member `{2}'
ka: `{0}': შეუძლებელია წვდომის მოდიფიკატორების შეცვლა, როცა გადაფარავთ `{1}', მემკვიდრეობით წევრს `{2}'

en: `{0}': static types cannot be used as return types
ka: `{0}': სტატიკურ ტიპებს დაბრუნები ტიპებში ვერ გამოიყენებთ

en: `{0}': Cannot specify constraints for overrides and explicit interface implementation methods
ka: `{0}': გადაფარვებს და აშკარა ინტერფეისის განხორციელების მეთოდებს შეზღუდვებს ვერ მიუთითებთ

en: New virtual member `{0}' is declared in a sealed class `{1}'
ka: ახალი ვირტუალური წევრი '{0}' აღწერილია დაბეჭდილ კლასში '{1}'

en: Inconsistent accessibility: property type `
ka: არამდგრადი წვდომადობა: ნაკვეთის ტიპი

en: Inconsistent accessibility: indexer return type `
ka: არამდგრადი წვდომადობა: ინდექსერის დაბრუნების ტიპი

en: Inconsistent accessibility: return type `
ka: არამდგრადი წვდომადობა: დაბრუნების ტიპი

en: Inconsistent accessibility: field type `
ka: არამდგრადი წვდომადობა: ველის ტიპი

en: Parameters or local variables of type `{0}' cannot be declared in async methods or iterators
ka: მარამეტრებს ან ლოკალურ ცვლადებს ტიპით '{0}' ვერ გამოაცხადებთ ასინქრონულ მეთოდებში ან იტერატორებში

en: Local variables of type `{0}' cannot be used inside anonymous methods, lambda expressions or query expressions
ka: ლოკალურ ცვლადებს ტიპით '{0}' ვერ გამოიყენებთ ანონიმური მეთოდების, ლამბდა გამოსახულებების ან მოთხოვნის გამოსახულებების შიგნით

en: Field or property cannot be of type `{0}'
ka: ველს ან ნაკვეთს ვერ აღწერთ ტიპით '{0}'

en: Type parameter `{0}' cannot be declared const
ka: ტიპის პარამეტრს '{0}' მუდმივად ვერ აღწერთ

en: The type `{0}' cannot be declared const
ka: ტიპს '{0}' მუდმივად ვერ აღწერთ

en: The evaluation of the constant value for `{0}' involves a circular definition
ka: კონსტანტის მნიშვნელობის შემოწმება '{0}'-სთვის წრიულ აღწერას შეიცავს

en: Constant value `{0}' cannot be converted to a `{1}'
ka: მუდმივ მნიშვნელობას '{0}' '{1}'-ში ვერ გადაიყვანეთ

en: Constant value `{0}' cannot be converted to a `{1}' (use `unchecked' syntax to override)
ka: მუდმივ მნიშვნელობას '{0}' '{1}'-ში ვერ გადაიყვანეთ (გადასაფარად გამოიყენეთ სინტაქსი 'unchecked')

en: Ambiguous user defined operators `{0}' and `{1}' when converting from `{2}' to `{3}'
ka: ბუნდოვანი მომხმარებლის მიერ აღწერილი ოპერატორები `{0}' და `{1}' როცა `{2}'-დან `{3}'-ში გადაგყავთ

en: `{0}' cannot declare a body because it is marked extern
ka: '{0}' სხეულს ვერ აღწერს, რადგან მონიშნულია, როგორც extern

en: `{0}' cannot declare a body because it is marked abstract
ka: '{0}' სხეულს ვერ აღწერს, რადგან მონიშნულია, როგორც abstract

en: `{0}' must have a body because it is not marked abstract or extern. The property can be automatically implemented when you define both accessors
ka: '{0}'-ს სხეული უნდა ჰქონდეს, რადგან ის არაა დანიშნული საკვანძო სიტყვებით abstract ან extern. თვისება, შეიძლება, ავტომატურად განხორციელდეს, როცა ორივე აქსესორებს განსაზღვრავთ

en: `{0}' must have a body because it is not marked abstract, extern, or partial
ka: '{0}'-ს სხეული უნდა ჰქონდეს, რადგან ის არაა განსაზღვრული საკვანძო სიტყვებით abstract, extern ან partial

en: `{0}': Structs cannot contain protected members
ka: '{0}': სტრუქტურები არ შეიძლება, დაცულ წევრებს შეიცავდეს

en: `{0}': Static classes cannot contain protected members
ka: '{0}': სტატიკური კლასები, არ შეიძლება, დაცულ წევრებს შეიცავდეს

en: Constraints are not allowed on non-generic declarations
ka: შეზღუდვები დაუშვებელია არა-ზოგადი აღწერებისთვის

en: `{0}': A constraint references nonexistent type parameter `{1}'
ka: `{0}': შეზღუდვა მიმართავს არარსებული ტიპის პარამეტრს `{1}'

en: Inconsistent accessibility: parameter type `{0}' is less accessible than delegate `{1}'
ka: არამდგრადი წვდომადობა: პარამეტრის ტიპი '{0}' ნაკლებად წვდომადია, ვიდრე დელეგატი '{1}'

en: Cannot create delegate from method `{0}' because it is a member of System.Nullable<T> type
ka: ვერ შევქმენი დელეგატი მეთოდიდან '{0}', რადგან ის System.Nullable<T> ტიპის წევრია

en: Extension method `{0}' of value type `{1}' cannot be used to create delegates
ka: გაფართოების მეთოდს '{0}' მნიშვნელობის ტიპისთვის '{1}' დელეგატების შესაქმნელად ვერ გამოიყენებთ

en: Cannot create delegate from partial method declaration `{0}'
ka: ნაწილობრივი მეთოდის აღწერიდან '{0}' დელეგატს ვერ შექმნით

en: Cannot create delegate with `{0}' because it has a Conditional attribute
ka: ვერ შევქმენი დელეგატი '{0}'-ით, რადგან მას აქვს ატრიბუტი Conditional

en: A method or delegate `{0} {1}' parameters and return type must be same as delegate `{2} {3}' parameters and return type
ka: მეთოდის ან დელეგატის `{0} {1}' პარამეტრები და დაბრუნების ტიპი იგივე უნდა იყოს, რაც დელეგატის `{2} {3}' პარამეტრები და დაბრუნების ტიპი

en: A method or delegate `{0}' parameters do not match delegate `{1}' parameters
ka: მეთოდის ან დელეგატის `{0}' პარამეტრები არ ემთხვევა დელეგატის `{1}' პარამეტრებს

en: A method or delegate `{0} {1}' return type does not match delegate `{2} {3}' return type
ka: მეთოდის ან დელეგატის `{0} {1}' დაბრუნების ტიპი არ ემთხვევა დელეგატის `{2} {3}' დაბრუნების ტიპს

en: Method name expected
ka: მოველოდი მეთოდის სახელს

en: Error generating XML documentation file `{0}' (`{1}')
ka: გენერაციის შეცდომა XML დოკუმენტაციის ფაილისთვის `{0}' (`{1}')

en: Source file `
ka: წყარო ფაილი

en: No files to compile were specified
ka: დასაკომპილებელი ფაილები მითითებული არაა

en: Platform option `anycpu32bitpreferred' is valid only for executables
ka: პლატფორმის პარამეტრი `anycpu32bitpreferred', მხოლოდ, გამშვები ფაილებისთვისაა სწორი

en: If no source files are specified you must specify the output file with -out:
ka: თუ წყარო ფაილები მითითებული არაა, შეგიძლიათ, გამოტანის ფაილი მიუთითოთ პარამეტრით -out:

en: Output file name is not valid
ka: გამოტანის ფაილის სახელი არასწორია

en: An expression tree cannot contain a dynamic operation
ka: გამოსახულების ხე არ შეიძლება, დინამიკურ ოპერაციას შეიცავდეს

en: Dynamic operation cannot be compiled without `Microsoft.CSharp.dll' assembly reference
ka: დინამიკური ოპერაციების კომპილაცია შეუძლებელია `Microsoft.CSharp.dll' ანაწყობის მიმართვის გარეშე

en: `{0}' is inaccessible due to its protection level
ka: `{0}' მიუწვდომელია მისი უსაფრთხოების დონის გამო

en: A constant `{0}' of reference type `{1}' can only be initialized with null
ka: მუდმივა `{0}' მიმართვის ტიპისთვის `{1}' მხოლოდ, ნულით შეგიძლიათ, ინიციალიზაცია გააკეთოთ

en: Keyword `void' cannot be used in this context
ka: საკვანძო სიტყვას 'vod' ამ კონტექსტში ვერ გამოიყენებთ

en: Cannot convert type `{0}' to `{1}'
ka: ტიპის '{0}' გადაყვანა '{1}'-ში შეუძლებელია

en: Cannot implicitly convert type `{0}' to `{1}'. An explicit conversion exists (are you missing a cast?)
ka: არაცხადი გადაყვანა ტიპისთვის '{0}' ტიპში '{1}' შეუძლებელია. არსებობს ცხადი გადაყვანა (გაკლიათ დაკასტვა?)

en: Cannot implicitly convert type `{0}' to `{1}'
ka: '{0}'-ის '{1}'-ში არაცხადად გადაყვანა შეუძლებელია

en: The {0} `{1}' cannot be used with type arguments
ka: {0} '{1}' არ შეიძლება, ტიპის არგუმენტებთან ერთად იქნეს გამოყენებული

en: `{0}' does not contain a definition for `{1}'
ka: `{0}' არ შეიცავს აღწერას `{1}'-სთვის

en: A ref or out argument must be an assignable variable
ka: არგუმენტები ref ან out მინიჭებადი ცვლადები უნდა იყოს

en: The left-hand side of an assignment must be a variable, a property or an indexer
ka: მინიჭების მარცხენა მხარე ცვლადი, თვისება, ან ინდექსერი უნდა იყოს

en: The operation in question is undefined on void pointers
ka: საინტერესო ოპერაცია აღუწერელია ცარიელ მაჩვენებლებზე

en: Internal compiler error: {0}
ka: შიდა კომპლატორის შეცდომა: {0}

en: A constant value is expected
ka: მოველოდი მუდმივას მნიშვნელობას

en: An attribute argument must be a constant expression, typeof expression or array creation expression
ka: ატრიბუტის არგუმენტი გამოსახულება constant, typeoff ან მასივის შექმნა უნდა იყოს

en: The class `{0}' has no constructors defined
ka: კლასს '{0}' კონსტრუქტორები განსაზღვრული არ აქვს

en: An element access expression cannot use named argument
ka: ელემენტის წვდომის გამოსახულება სახელიან არგუმენტს ვერ გამოიყენებს

en: The `{0}' operator cannot be applied to operand of type `{1}'
ka: ოპერატორს '{0}' ოპერანდის ტიპზე '{1}' ვერ გადაატარებთ

en: An expression tree cannot contain an unsafe pointer operation
ka: გამოსახულების ხე, არ შეიძლება, არაუსაფრთხო მაჩვენებლის ოპერაციას შეიცავდეს

en: `{0}' is a `{1}' but a `{2}' was expected
ka: `{0}' `{1}'-ია, მაგრამ მოველოდ `{2}'-ს

en: Expression denotes a `{0}', where a `{1}' was expected
ka: გამოსახულება მიუთითებს `{0}'-ზე მაშინ, როცა მოველოდი: `{1}'

en: Pointers and fixed size buffers may only be used in an unsafe context
ka: მაჩვენებლები და ფიქსირებული ზომის ბუფერები, მხოლოდ, სახიფათო კონტექსტში შეგიძლიათ, გამოიყენოთ

en: A pointer must be indexed by only one value
ka: მაჩვენებელი, მხოლოდ, ერთი მნიშვნელობით უნდა იყოს დაინდექსებული

en: The name `{0}' does not exist in the current context
ka: სახელი '{0}' მიმდინარე კონტექსტში არ არსებობს

en: Dynamic keyword requires `{0}' to be defined. Are you missing System.Core.dll assembly reference?
ka: დინამიკურ საკვანძო სიტყვას '{0}'-ის აღწერა სჭირდება. აკლია მიმართვა ანაწყობთან System.Core.dll?

en: A local variable `{0}' cannot be used before it is declared. Consider renaming the local variable when it hides the member `{1}'
ka: ლოკალურ ცვლადს '{0}' ვერ გამოიყენებთ, სანამ არ აღწერთ. გადაარქვით ლოკალურ ცვლადს სახელი, როცა ის მალავს წევრს '{1}'

en: A local variable `{0}' cannot be used before it is declared
ka: ლოკალურ ცვლადს '{0}' აღწერამდე ვერ გამოიყენებთ

en: System.Void cannot be used from C#. Consider using `void'
ka: System.Void-ს C#-დან ვერ გამოიყენებთ. სჯობს, გამოიყენოთ `void'

en: The type or namespace name `{0}' could not be found in the global namespace. Are you missing {1} assembly reference?
ka: ტიპის ან სახელების სივრცის სახელი '{0}' აღმოჩენილი არაა გლობალურ სახელების სივრცეში. {1} ანაწყობთან მიმართვა ხომ არ გაკლიათ?

en: The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing {2} assembly reference?
ka: ტიპი ან სახელების სივრცის სახელი '{0}' არ არსებობს სახელების სივრცეში '{1}'. {2} ანაწყობთან მიმართვა ხომ არ გაკლიათ?

en: Cannot call an abstract base member `{0}'
ka: ვერ გამოიძახებთ აბსტრაქტულ საბაზისო წევრს '{0}'

en: Cannot access protected member `{0}' via a qualifier of type `{1}'. The qualifier must be of type `{2}' or derived from it
ka: დაცულ წევრთან '{0}' წვდომა შეუძლებელია კვალიფიკატორის ტიპით '{1}'. კვალიფიკატორი ტიპით '{2}' ან მისგან მიღებული უნდა იყოს

en: Fields of static readonly field `{0}' cannot be assigned to (except in a static constructor or a variable initializer)
ka: სტატიკური მხოლოდ-წაკითხვადი ველის '{0}' ველები ვერ იქნება მინიჭებული (სტატიკური კონსტრუქტორის ან ცვლადი ინიციალიზატორის გარდა)

en: Members of readonly field `{0}' cannot be modified (except in a constructor or a variable initializer)
ka: სტატიკური მხოლოდ-წაკითხვადი ველის '{0}' ველები ვერ შეიცვლება (სტატიკური კონსტრუქტორის ან ცვლადი ინიციალიზატორის გარდა)

en: Members of value type `{0}' cannot be assigned using a property `{1}' object initializer
ka: მნიშვნელობის ტიპის '{0}' წევრებს ვერ მიანიჭებთ თვისების '{1}' ობიექტის ინიციალიზატორის გამოყენებით

en: Cannot modify a value type return value of `{0}'. Consider storing the value in a temporary variable
ka: '{0}'-ის დაბრუნების მნიშვნელობის ტიპის შეცვლა შეუძლებელია. იფიქრეთ, მნიშვნელობა დროებით ცვლადში შეინახოთ

en: Cannot assign to members of `{0}' because it is a `{1}'
ka: '{0}'-ის წევრებზე მინიჭება შეუძლებელია, რადგან ის '{1}'-ია

en: Static member `{0}' cannot be accessed with an instance reference, qualify it with a type name instead
ka: სტატიკურ წევრთან '{0}' წვდომა შეუძლებელია გაშვებულ ასლთან მიმართვით. უკეთესია, თუ მას კვალიფიკაციას ტიპის სახელით მიანიჭებთ

en: A field initializer cannot reference the nonstatic field, method, or property `{0}'
ka: ველის ინიციალიზატორი ვერ მიმართავს არასტატიკურ ველს, მეთოდს ან თვისებას '{0}'

en: Constructor initializer cannot access primary constructor parameters
ka: კონსტრუქტორის ინიციალიზატორს ძირითადი კონსტრუქტორის პარამეტრებთან წვდომა არ აქვს

en: An object reference is required to access primary constructor parameter `{0}'
ka: ობიექტის მიმართვა აუცილებელია ძირითადი კონსტრუქტორის პარამეტრთან '{0}' წვდომისთვის

en: An object reference is required to access non-static member `{0}'
ka: ობიექტის მიმართვა აუცილებელი არასტატიკურ წევრთან '{0}' წვდომისთვის

en: Cannot access a nonstatic member of outer type `{0}' via nested type `{1}'
ka: გარე ტიპის '{0}' არასტატიკურ წევრთან წვდომა შეუძლებელია ერთმანეთში ჩადგმული ტიპით '{1}'

en: Cannot modify the result of an unboxing conversion
ka: ყუთიდან ამოღების გადაყვანის შედეგის შეცვლა შეუძლებელია

en: Type `{0}' does not contain a member `{1}' and the best extension method overload `{2}' has some invalid arguments
ka: ტიპი '{0}' არ შეიცავს წევრს '{1}' და საუკეთესო გაფართოების მეთოდის გადამეტტვირთვას '{2}' არასწორი არგუმენტები აქვს

en: An expression tree cannot contain an expression with method group
ka: გამოსახულებების ხე არ შეიძლება, მეთოდების ჯგუფის შემცველ გამოსახულებას შეიცავდეს

en: Partial methods with only a defining declaration or removed conditional methods cannot be used in an expression tree
ka: ნაწილობრივი მეთოდები, რომლებსაც, მხოლოდ, აღმწერი გამოცხადება ან წაშლილი პირობითი მეთოდები აქვთ, გამოსახულებების ხეში ვერ გამოიყენება

en: Cannot convert method group `{0}' to non-delegate type `{1}'. Consider using parentheses to invoke the method
ka: მეთოდის ჯგუფის '{0}' გადაყვანა შეუძლებელია არადელეგადის ტიპში '{1}'. მეთოდის ჩასაწოდებლად ფრჩხილები გამოიყენეთ

en: The type `{0}' does not contain a constructor that takes `{1}' arguments
ka: ტიპი '{0}' არ შეიცავს კონსტრუქტორს, რომელიც '{1}' არგუმენტს იღებს

en: Type `{0}' does not contain a member `{1}' and the best extension method overload `{2}' cannot be dynamically dispatched. Consider calling the method without the extension method syntax
ka: ტიპი '{0}' არ შეიცავს წევრს '{1}' და საუკეთესო გაფართოების მეთოდის გადამეტტვირთვის '{2}' დინამიკური მართვა შეუძლებელია. იფიქრეთ, მეთოდი გაფართოების მეთოდის სინტაქსის გარეშე გამოიძახოთ

en: The call is ambiguous between the following methods or properties: `{0}' and `{1}'
ka: გამოძახება ბუნდოვანია შემდეგ ორ ტიპს ან თვისებას შორის: '{0}' და '{1}'

en: The best overloaded collection initalizer method `{0}' cannot have `ref' or `out' modifier
ka: საუკეთესო გადამეტტვირთული კოლექცის ინიციალიზატორის მეთოდს '{0}' მოდიფიკატორები 'ref' ან 'out' ვერ ექნება

en: The best overloaded collection initalizer method `{0}' has some invalid arguments
ka: საუკეთესო გადამეტტვირთული კოლექცის ინიციალიზატორის მეთოდს '{0}' არასწორი არგუმენტები აქვს

en: Delegate `{0}' has some invalid arguments
ka: დელეტაგის '{0}' ზოგიერთი არგუმენტი არასწორია

en: The best overloaded method match for `{0}' has some invalid arguments
ka: საუკეთესო გადამეტტვირთული მეთოდის დამთხვევას '{0}' რამდენიმე არასწორი არგუმენტი აქვს

en: Argument `#{0}' does not require `{1}' modifier. Consider removing `{1}' modifier
ka: არგუმენტი `#{0}'-ს არ სჭირდება მოდიფიკატორი `{1}'. უკეთესია, თუ წაშლით`{1}' მოდიფიკატორს

en: Argument `#{0}' is missing `{1}' modifier
ka: არგუმენტს `#{0}' აკლია მოდიფიკატორი `{1}'

en: Argument `#{0}' cannot convert `{1}' expression to type `{2}'
ka: არგუმენტი `#{0}' ვერ გადავიყვანე `{1}' გამოსახულება ტიპში `{2}'

en: The type arguments for method `{0}' cannot be inferred from the usage. Try specifying the type arguments explicitly
ka: ტიპის არგუმენტები მეთოდისთვის '{0}' ვერ გამოვიცანი მისი გამოყენებიდან. სცადეთ, ტიპის არგუმენტები აშკარად მიუთითოთ

en: No overload for method `{0}' takes `{1}' arguments
ka: გადამეტტვირთვა მეთოდისთვის '{0}' '{1}' არგუმენტით არ არსებობს

en: The delegate `{0}' does not contain a parameter named `{1}'
ka: დელეგატი '{0}' არ შეიცავს პარამეტრს სახელით '{1}'

en: The best overloaded method match for `{0}' does not contain a parameter named `{1}'
ka: საუკეთესო გადამეტტვირთული მეთოდის დამთხვევა '{0}'-სთვის არ შეიცავს პარამეტრს სახელად '{1}'

en: Named argument `{0}' cannot be used for a parameter which has positional argument specified
ka: სახელიან არგუმენტს '{0}' ვერ გამოიყენებთ პარამეტრისთვის, რომელსაც პოზიციური არგუმენტი აქვს მითითებული

en: You cannot use fixed size buffers contained in unfixed expressions. Try using the fixed statement
ka: დაუფიქსირებელ გამოსახულებებში არსებულ ფიქსირებული ზომის ბუფერებს ვერ გამოიყენეთ. სცადეთ, ფიქსირებული პროცედურა გამოიყენოთ

en: `{0}': Fixed size buffers can only be accessed through locals or fields
ka: `{0}': ფიქსირებული ზომის ბუფერებთან წვდომა, მხოლოდ, ლოკალურებით ან ველებით შეგიძლიათ

en: A static readonly field `{0}' cannot be passed ref or out (except in a static constructor)
ka: სტატიკური მხოლოდ-კითხვადი ველი '{0}' არ შეძლება, ref-ს ან out-ს გადაეცეს (სტატიკური კონსტრუქტორის გარდა)

en: A readonly field `{0}' cannot be passed ref or out (except in a constructor)
ka: მხოლოდ-კითხვადი ველი '{0}' არ შეძლება, ref-ს ან out-ს გადაეცეს (კონსტრუქტორის გარდა)

en: Fields of static readonly field `{0}' cannot be passed ref or out (except in a static constructor)
ka: სტატიკური მხოლოდ-კითხვადი ველის '{0}' ველები არ შეძლება, ref-ს ან out-ს გადაეცეს (სტატიკური კონსტრუქტორის გარდა)

en: Members of readonly field `{0}' cannot be passed ref or out (except in a constructor)
ka: მხოლოდ-კითხვადი ველის '{0}' წევრები, არ შეძლება, ref-ს ან out-ს გადაეცეს (კონსტრუქტორის გარდა)

en: A static readonly field `{0}' cannot be assigned to (except in a static constructor or a variable initializer)
ka: სტატიკური მხოლოდ-წაკითხვადი ველი '{0}' ვერ იქნება მინიჭებული (სტატიკური კონსტრუქტორის ან ცვლადი ინიციალიზატორის გარდა)

en: A readonly field `{0}' cannot be assigned to (except in a constructor or a variable initializer)
ka: მხოლოდ-წაკითხვადი ველი '{0}' ვერ იქნება მინიჭებული (მხოლოდ კონსტრუქტორში, ან ცვლად ინიციალიზატორში)

en: Use of possibly unassigned field `{0}'
ka: გამოიყენება ალბათ მიუნიჭებელი ველი `{0}'

en: Property or event `{0}' is not supported by the C# language
ka: თვისება ან მოვლენა '{0}' C# ენის მიერ მხარდაჭერილი არაა

en: A range variable `{0}' may not be passes as `ref' or `out' parameter
ka: შუალედი ცვლადი `{0}' არ შეიძლება გადაიცეს, როგორც 'ref' ან 'out' პარამეტრი

en: Property or indexer `{0}' cannot be assigned to (it is read-only)
ka: ინდექსერის '{0}' თვისებას ვერაფერს მიანიჭებთ (ის მხოლოდ-წაკთხვადია)

en: The property or indexer `{0}' cannot be used in this context because the set accessor is inaccessible
ka: ინდექსერის '{0}' თვისებას ამ კონტექსტში ვერ გამოიყენებთ, რადგან აქსესორი 'set' ხელმიუწვდომელია

en: The property or indexer `{0}' cannot be used in this context because it lacks the `get' accessor
ka: ინდექსერის '{0}' თვისებას ამ კონტექსტში ვერ გამოიყენებთ, რადგან მას 'get' აქსესორი არ აქვს

en: The property or indexer `{0}' cannot be used in this context because the get accessor is inaccessible
ka: ინდექსერის '{0}' თვისებას ამ კონტექსტში ვერ გამოიყენებთ, რადგან აქსესორი 'get' ხელმიუწვდომელია

en: The event `{0}' can only appear on the left hand side of `+=' or `-=' operator
ka: მოვლენა '{0}', ოპერატორების '+=' ან '-=', მხოლოდ, მარცხენა მხარეს შეიძლება, გამოჩნდნენ

en: The event `{0}' can only appear on the left hand side of += or -= when used outside of the type `{1}'
ka: მოვლენა '{0}', ოპერატორების '+=' ან '-=', მხოლოდ, მარცხენა მხარეს შეიძლება, გამოჩნდნენ, როცა გამოიყენება ტიპის '{1}' გარეთ

en: An implicitly typed local variable declaration cannot be initialized with `{0}'
ka: არაცხადად შეყვანილი ლოკალური ცვლადის აღწერის ინიციალიზაცია შეუძლებელია '{0}'-ით

en: The contextual keyword `var' may only appear within a local variable declaration
ka: კონტექსტური საკვანძო სიტყვა 'var', მხოლოდ, ლოკალური ცვლადის გამოცხადებაში შეიძლება, გამოჩნდეს

en: The enumerator value `{0}' is outside the range of enumerator underlying type `{1}'
ka: ჩამოთვლის მნიშვნელობა '{0}' მისი ქვედა დონის ჩამონათვლის ტიპის '{1}' დაშვებულ შუალედს გარეთაა

en: An item in an enumeration cannot have an identifier `{0}'
ka: ელემენტს ჩამონათვალში ვერ ექნება იდენტიფიკატორი '{0}'

en: Type byte, sbyte, short, ushort, int, uint, long or ulong expected
ka: მოველოდი ტიპს byte, sbyte, short, ushort, int, uint, long, ან ulong

en: Detection Parsing Error
ka: დამუშავების შეცდომის აღმოჩენა

en: Operator `{0}' is ambiguous on an operand of type `{1}'
ka: ოპერატორი '{0}' ბუნდოვანია ოპერანდზე ტიპისთვის '{1}'

en: Cannot take the address of the given expression
ka: მითითებული გამოსახულების მისამართის აღება შეუძლებელია

en: You can only take the address of unfixed expression inside of a fixed statement initializer
ka: დაუფიქსირებელი გამოსახულებების მისამართის აღება, მხოლოდ, ფიქსირებული პროცედურის ინიციალიზატორის შინიდან შეგიძლიათ

en: The * or -> operator must be applied to a pointer
ka: მაჩვენებელზე * ან -> ოპერატორის გადატარება აუცილებელია

en: The operand of an increment or decrement operator must be a variable, property or indexer
ka: ინკრემენტის ოპერანდი ან დეკრემენტის ოპერატორი ცვლადი, თვისება, ან ინდექსერი უნდა იყოს

en: The `{0}' operator cannot be applied to an operand of pointer type
ka: ოპერატორს '{0}' ვერ გადაატარებთ მაჩვენებლის ტიპის ოპერანდზე

en: The `as' operator cannot be used with a non-reference type parameter `{0}'. Consider adding `class' or a reference type constraint
ka: ოპერატორს 'as' ვერ გამოიყენებთ არა-მიმართვის ტიპის პარამეტრთან '{0}' ერთად. იფიქრეთ, დაამატოთ 'class' ან მიმართვის ტიპის შეზღუდვა

en: The `as' operator cannot be used with a non-nullable value type `{0}'
ka: ოპერატორს 'as' ვერ გამოიყენებთ არაგანულებადი მნიშვნელობის ტიპთან '{0}' ერთად

en: Cannot convert type `{0}' to `{1}' via a built-in conversion
ka: ჩაშენებული გადაყვანით ტიპს '{0}' '{1}'-ში ვერ გადავიყვან

en: Cannot convert to static type `{0}'
ka: სტატიკურ ტიპში '{0}' გადაყვანა შეუძლებელია

en: The `default value' operator cannot be applied to an operand of a static type
ka: ოპერატორს 'default value' ვერ გადაატარებთ სტატიკური ტიპის ოპერანდზე

en: Operator `{0}' cannot be applied to operands of type `{1}' and `{2}'
ka: ოპერატორს '{0}' ვერ გადაატარებთ ოპერანდებზე ტიპით '{1}' და '{2}'

en: To cast a negative value, you must enclose the value in parentheses
ka: უარყოფითი მნიშვნელობის დაკასტვისთვის მნიშვნელობა ფრჩხილებში უნდა ჩასვათ

en: A user-defined operator `{0}' must have each parameter type and return type of the same type in order to be applicable as a short circuit operator
ka: მომხმარებლის აღწერილ ოპერატორს '{0}' თითოეული პარამეტრის ტიპი და დაბრუნების ტიპი იგივე უნდა ჰქონდეს, რომ გამოყენებადი იყოს, როგორც მოკლე წრედის ოპერატორი

en: The type `{0}' must have operator `true' and operator `false' defined when `{1}' is used as a short circuit operator
ka: ტიპს '{0}' უნდა ჰქონდეს ოპერატორი 'true' და ოპერატორი 'false' აღწერილი, როცა '{1}' მოკლე წრედის ოპერატორად გამოიყენება

en: Type of conditional expression cannot be determined as `{0}' and `{1}' convert implicitly to each other
ka: პირობითი გამოსახულების ტიპის დადგენა შეუძლებელია, რადგან '{0}'-ისა და '{1}'-ის ერთმანეთში გადაყვანა არაცხადად ხდება

en: Type of conditional expression cannot be determined because there is no implicit conversion between `{0}' and `{1}'
ka: პირობით გამოსახულების ტიპის დადგენა შეუძლებელია, რადგან არ არსებობს არაცხადი გადაყვანა '{0}'-სა და '{1}'-ს შორის

en: Use of unassigned local variable `{0}'
ka: მიუნიჭებელი ლოკალური ცვლადის '{0}' გამოყენება

en: Parameter `{0}' cannot be used inside `{1}' when using `ref' or `out' modifier
ka: პარამეტრს '{0}' ვერ გამოიყენებთ '{1}'-ის შიგნით, როცა 'ref' ან 'out' მოდიფიკატორების იყენებთ

en: Use of unassigned out parameter `{0}'
ka: გამოიყენება მიუნიჭებელი გამავალი პარამეტრი '{0}'

en: Cannot invoke a non-delegate type `{0}'
ka: არა-დელეგატი ტიპის '{0}' ჩაწოდება შეუძლებელია

en: The member `{0}' cannot be used as method or delegate
ka: წევრს '{0}' დელეგატის მეთოდად ვერ გამოიყენებთ

en: Do not directly call your base class Finalize method. It is called automatically from your destructor
ka: არ გამოიძახოთ თქვენი საბაზისო კლასის მეთოდი Finalize. მას თქვენი დესტრუქტორიდან ავტომატურად ვიძახებთ

en: Destructors and object.Finalize cannot be called directly. Consider calling IDisposable.Dispose if available
ka: დესტრუქტორებს და object.Finalize-ს პირდაპირ ვერ გამოიძახეთ. სცადეთ, გამოიძახოთ IDisposable.Dispose თუ ის ხელმისაწვდომია

en: The base call to method `{0}' cannot be dynamically dispatched. Consider casting the dynamic arguments or eliminating the base access
ka: საბაზისო გამოძახება მეთოდამდე '{0}' დინამიკურად ვერ გაეშვება. იფიქრეთ დინამიკური არგუმენტების დაკასტვაზე ან საბაზისო წვდომის მოცილებაზე

en: `{0}': cannot explicitly call operator or accessor
ka: `{0}': აშკარად ოპერატორს ან აქსესორს ვერ გამოიძახებთ

en: Unsafe type `{0}' cannot be used in an object creation expression
ka: სახიფათო ტიპს '{0}' ობიექტის შექმნის გამოსახულებაში ვერ გამოიყენებთ

en: Cannot create an instance of the variable type `{0}' because it does not have the new() constraint
ka: ცვლადი ტიპის '{0}' გაშვებული ასლის შექმნა შეუძლებელია, რადგან მას შეზღუდვა new() არ აქვს

en: `{0}': cannot provide arguments when creating an instance of a variable type
ka: `{0}': ვერ მივაწვდით არგუმენტებს, როცა ცვლადი ტიპის გაშვებული ასლი იქმნება

en: Cannot create an instance of the static class `{0}'
ka: ვერ შევქმენი გაშვებული ასლი სტატიკური კლასისთვის '{0}'

en: Cannot create an instance of the abstract class or interface `{0}'
ka: ვერ შევქმენი გაშვებული ასლი აბსტრაქტული კლასისთვის ან ინტერფეისისთვის '{0}'

en: An implicitly typed local variable declarator cannot use an array initializer
ka: არაცხადად შეყვანილი ლოკალური ცვლადის გამომცხადებელი მასივის ინიციალიზატორს ვერ გამოიყენებს

en: An array initializer of length `{0}' was expected
ka: მოველოდი მასივის ინიციალიზატორს სიგრძით '{0}'

en: Array initializers can only be used in a variable or field initializer. Try using a new expression instead
ka: მასივის ინიციალიზატორები, მხოლოდ, ცვლადის ან ველის ინიციალიზატორში შეგიძლიათ, გამოიყენოთ. იფიქრეთ, ახალი გამოსახულება გამოიყენოთ

en: A nested array initializer was expected
ka: მოველოდი ერთმანეთში ჩალაგებულ მასივის ინიციალიზატორს

en: An expression tree cannot contain a multidimensional array initializer
ka: გამოსახულებების ხე არ შეიძლება, მრავალგანზომილებიანი მასივის ინიციალიზატორს შეიცავდეს

en: Cannot create an array with a negative size
ka: უარყოფითი ზომის მქონე მასივის შექმნა შეუძლებელია

en: Can only use array initializer expressions to assign to array types. Try using a new expression instead
ka: მასივის ინიციალიზატორის გამოსახულებებს მასივის ტიპებზე მისანიჭებლად ვერ გამოიყენებთ. სჯობ, ახალი გამოსახულება სცადოთ

en: The type of an implicitly typed array cannot be inferred from the initializer. Try specifying array type explicitly
ka: არაცხადად შეყვანილი მასივის ტიპს ინიციალიზატორიდან ვერ მოაცილებთ. სცადეთ, მასივის ტიპი აშკარად მიუთითოთ

en: The `this' object cannot be used before all of its fields are assigned to
ka: 'this' ობიექტის გამოყენება შეუძლებელია, სანამ მის ყველა ველს არ მანიჭებთ

en: Keyword `this' is not valid in a static property, static method, or static field initializer
ka: საკვანძო სიტყვა 'this' არასწორია სტატიკური თვისებისთვის, სტატიკური ველისთვის, ან სტატიკური ველის ინიციალიზატორისთვის

en: Anonymous methods inside structs cannot access instance members of `this'. Consider copying `this' to a local variable outside the anonymous method and using the local instead
ka: ანონიმურ მეთოდებს სტრუქტურების 'this'-ის გაშვებული ასლის წევრებთან წვდომა არ აქვთ. იფიქრეთ, დააკოპიროთ 'this' ლოკალურ ცვლადში ანონიმური მეთოდის გარეთ, ან გამოიყენეთ ლოკალური

en: Keyword `this' is not available in the current context
ka: საკვანძო სიტყვა 'this' ხელმიუწვდომელია მიმდინარე კონტექსტში

en: Cannot take the address of `this' because it is read-only
ka: 'this'-ის მისამართის აღება შეუძლებელია, რადგან ის მხოლოდ-წაკითხვადია

en: Cannot pass `this' as a ref or out argument because it is read-only
ka: 'this'-ს ვერ გადასცემთ ref ან out არგუმენტით, რადგან ის მხოლოდ-კითხვადია

en: Cannot assign to `this' because it is read-only
ka: ვერ მივანიჭე 'this'-ს, რადგან ის მხოლოდ-წაკითხვადია

en: The __arglist construct is valid only within a variable argument method
ka: კონსტრუქტი __arglist, მხოლოდ, ცვლადი არგუმენტის მეთოდშია სწორი

en: An expression tree cannot contain a method with variable arguments
ka: გამოსახულებების ხე არ შეიძლება, ცვლადი არგუმენტების მქონე მეთოდს შეიცავდეს

en: The typeof operator cannot be used on the dynamic type
ka: ოპერატორს typeof დინამიკურ ტიპზე ვერ გამოიყენებთ

en: `{0}': an attribute argument cannot use type parameters
ka: `{0}': ატრიბუტის არგუმენტი ტიპის პარამეტრებს ვერ გამოიყენებს

en: `{0}' does not have a predefined size, therefore sizeof can only be used in an unsafe context (consider using System.Runtime.InteropServices.Marshal.SizeOf)
ka: '{0}'-ს წინასწარ აღწერილი ზომა ვერ ექნება, ამიტომ, sizeof()-ს, მხოლოდ, სახიფათო კონტექსტის შიგნით თუ გამოიყენებთ (იფიქრეთ System.Runtime.InteropServices.Marshal.SizeOf-ის გამოყენებაზე)

en: Alias `{0}' not found
ka: ფსევდონიმი `{0}' აღმოჩენილი არაა

en: The namespace alias qualifier `::' cannot be used to invoke a method. Consider using `.' instead
ka: სახელების სივრცის ფსევდონიმის კვალიფიკატორს '::' მეთოდის ჩასაწოდებლად ვერ გამოიყენებთ. იფიქრეთ, სამაგიეროდ '.' გამოიყენოთ

en: Cannot perform member binding on `null' value
ka: წევრის მიმაგრების ჩატარება შეუძლებელია მნიშვნელობაზე 'null'

en: `{0}': cannot reference a type through an expression. Consider using `{1}' instead
ka: `{0}': ტიპთან მიმართვა შეუძლებელია გამოსახულების გავლით. იფიქრეთ, სამაგიეროდ, `{1}' გამოიყენოთ

en: A nested type cannot be specified through a type parameter `{0}'
ka: ერთმანეთში ჩალაგებულ ტიპს ვერ მიუთითებთ ტიპის პარამეტრით '{0}'

en: Alias `{0}' cannot be used with `::' since it denotes a type. Consider replacing `::' with `.'
ka: ფსევდონიმს '{0}' ვერ გამოიყენებთ '::'-სთან ერთად, რადგან ის ტიპს გამოხატავს. იფიქრეთ '::'-ის '.'-ით ჩანაცვლებაზე

en: The nested type `{0}' does not exist in the type `{1}'
ka: ერთმანეთში ჩაშენებული ტიპი '{0}' არ არსებობს ტიპში '{1}'

en: Type `{0}' does not contain a definition for `{1}' and no extension method `{1}' of type `{0}' could be found. Are you missing {2}?
ka: ტიპი '{0}' არ შეიცავს აღწერას '{1}'-სთვის და გაფართოების მეთოდი '{1}' ტიპით '{0}' აღმოჩენილი არაა. {2} ხომ არ გაკლიათ?

en: Cannot apply indexing with [] to an expression of type `{0}'
ka: []-ის მქონე დაინდექსებას ვერ გადაატარებთ გამოსახულებაზე ტიპით '{0}'

en: Wrong number of indexes `{0}' inside [], expected `{1}'
ka: არასწორი ინდექსების რაოდენობა '{0} []-ის შიგნით. მოველოდი: '{1}'

en: The indexer base access cannot be dynamically dispatched. Consider casting the dynamic arguments or eliminating the base access
ka: ინდექსერის საბაზისო წვდომის დინამიკური გაშვება შეუძლებელია. იფიქრეთ დინამიკური არგუმენტების დაკასტვაზე ან საბაზისო წვდომის მოცილებაზე

en: An expression tree may not contain a base access
ka: გამოსახულებების ხე არ შეიძლება, საბაზისო წვდომას არ შეიცავდეს

en: Keyword `base' is not available in a static method
ka: საკვანძო სიტყვა 'base' ხელმიუწვდომელია სტატიკურ მეთოდში

en: Keyword `base' is not available in the current context
ka: საკვანძო სიტყვა 'base' ხელმიუწვდომელია მიმდინარე კონტექსტში

en: A property, indexer or dynamic member access may not be passed as `ref' or `out' parameter
ka: თვისებას, ინდექსერს ან დინამიკური წევრის წვდომას 'ref' ან 'out' პარამეტრით ვერ გადასცემთ

en: Array elements cannot be of type `{0}'
ka: მასივი ელემენტები ვერ იქნება ტიპით '{0}'

en: Array elements cannot be of static type `{0}'
ka: მასივი ელემენტები ვერ იქნება სტატიკური ტიპით '{0}'

en: Cannot use a negative size with stackalloc
ka: უარყოფით ზომას stackalloc-თან ვერ გამოყენებთ

en: Cannot use stackalloc in finally or catch
ka: 'stackalloc'-ს 'finally'-სთან ან 'catch'-თან ერთად ვერ გამოიყენებთ

en: Member `{0}' cannot be initialized. An object initializer may only be used for fields, or properties
ka: წევრის '{0}' ინიციალიზაცია შეუძლებელია ობიექტი ინიციალიზატორები, მხოლოდ, ველებისთვის ან თვისებებისთვის შეგიძლიათ, გამოიყენოთ

en: Static field or property `{0}' cannot be assigned in an object initializer
ka: სტატიკურ ველს ან თვისებას '{0}' ობიექტის ინიციალიზატორში ვერ მიანიჭებთ

en: A field or property `{0}' cannot be initialized with a collection object initializer because type `{1}' does not implement `{2}' interface
ka: ველის ან თვისების '{0}' ინიციალიზაცია შეუძლებელია კოლექციის ობიექტის ინიციალიზატორით, რადგან ტიპი '{1}' არ ახორციელებს ინტერფეისს '{2}'

en: Inconsistent `{0}' member declaration
ka: არამდგრადი '{0}'-ის აღწერა

en: An object initializer includes more than one member `{0}' initialization
ka: ობიექტის ინიციალიზატორი ერთ წევრზე მეტ '{0}' ინიციალიზაციას შეიცავს

en: Cannot initialize object of type `{0}' with a collection initializer
ka: '{0}' ტიპის მქონე ობიექტს კოლექციის ინიციალიზატორით ინიციალიზაციას ვერ უზამთ

en: Object and collection initializers cannot be used to instantiate a delegate
ka: ობიექტის და კოლექციის ინიციალიზატორებს დელეგატის ინსტანცირებაში ვერ გამოიყენებთ

en: Anonymous types cannot be used in this expression
ka: ამ გამოსახულებაში ანონიმურ ტიპებს ვერ გამოიყენებთ

en: An anonymous type property `{0}' cannot be initialized with `{1}'
ka: ანონიმური ტიპის თვისებას '{0}' ვერ უზამთ ინიციალიზაციას '{1}'-ით

en: The modifier 'abstract' is not valid on fields. Try using a property instead
ka: მოდიფიკატორი 'abstract' არასწორია ველებზე. სცადეთ, property გამოიყენოთ

en: The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit)
ka: ატრიბუტი FieldOffset, მხოლოდ, იმ ტიპის წევრებზე შეგიძლიათ დასვათ, რომელსაც StructLayout(LayoutKind.Explicit) აქვს მითითებული

en: The FieldOffset attribute is not allowed on static or const fields
ka: ატრიბუტი 'FieldOffset' დაუშვებელია სტატიკურ ან მუდმივ ველებზე

en: Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead
ka: არ გამოიყენოთ ატრიბუტი 'System.Runtime.CompilerServices.FixedBuffer'. სამაგიეროდ გამოიყენეთ ველის მოდიფიკატორი 'fixed'

en: `{0}': Instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute
ka: `{0}': გაშვებული ასლის ველის ტიპი,რომლებიც მონიშნულია StructLayout(LayoutKind.Explicit)-ით, ატრიბუტი FieldOffset უნდა ჰქონდეს

en: `{0}': cannot declare variables of static types
ka: `{0}': სტატიკური ტიპის ცვლადების აღწერა შეუძლებელია

en: `{0}': Fixed size buffers type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double
ka: `{0}': ფიქსირებული ზომის ბუფერების ტიპი შეიძლება, იყოს ერთთ-ერთი: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float, ან double

en: `{0}': Fixed size buffer fields may only be members of structs
ka: `{0}': ფიქსირებული ზომის ბუფერის ველები, მხოლოდ, სტრუქტურების წევრი შეიძლება, იყოს

en: `{0}': Fixed size buffers must have a length greater than zero
ka: `{0}': ფიქსირებული ზომის ბუფერების ზომა 0-ზე მეტი უნდა იყოს

en: Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit
ka: ფიქსირებული ზომის ბუფერი `{0}' სიგრძით `{1}' და ტიპით `{2}' სცილდება ზღვარს 2^31

en: `{0}': A volatile field cannot be of the type `{1}'
ka: '{0}': აქროლადი ველი ვერ იქნება ტიპით '{1}'

en: `{0}': A field cannot be both volatile and readonly
ka: '{0}': ველი ერთდროულად აქროლად და მხოლოდ-წაკითხვადი ვერ იქნება

en: An automatically implemented property `{0}' must be fully assigned before control leaves the constructor. Consider calling the default struct contructor from a constructor initializer
ka: ავტომატურად განხორციელებული თვისება '{0}' სრულად მინიჭებული უნდა იყოს, სანამ კონტროლი კონსტრუქტორს დატოვებს. იფიქრეთ ნაგულისხმევი სტრუქტურის გამოძახებაზე კონსტრუქტორის ინიციალიზატორიდან

en: Field `{0}' must be fully assigned before control leaves the constructor
ka: ველი '{0}' ბოლომდე უნდა იყოს მინიჭებული, სანამ კონტროლი კონსტრუქტორს დატოვებს

en: Type parameter `{0}' inherits conflicting constraints `{1}' and `{2}'
ka: ტიპის პარამეტრი `{0}' მემკვიდრეობით ურთიერთგამომრიცხავ შეზღუდვებს, `{1}'-ს და `{2}'-ს იღებს

en: A constraint cannot be the dynamic type `{0}'
ka: შეზღუდვა ვერ იქნება დინამიკური ტიპი '{0}'

en: Inconsistent accessibility: constraint type `{0}' is less accessible than `{1}'
ka: არამდგრადი წვდომადობა: შეზღუდვა ტიპით '{0}' ნაკლებად წვდომადია, ვიდრე '{1}'

en: Duplicate constraint `{0}' for type parameter `{1}'
ka: ორმაგი შეზღუდვა '{0}' ტიპის პარამეტრისთვის '{1}'

en: Circular constraint dependency involving `{0}' and `{1}'
ka: წრიული შეზღუდვის დამოკიდებულება, რომელიც '{0}'-სა და '{1}'-ს ეხება

en: Type parameter `{0}' has the `struct' constraint, so it cannot be used as a constraint for `{1}'
ka: ტიპის პარამეტრს `{0}' აქვს შეზღუდვა `struct', ასე რომ, მას `{1}'-ის შეზღუდვად ვერ გამოიყენებთ

en: The class type constraint `{0}' must be listed before any other constraints. Consider moving type constraint to the beginning of the constraint list
ka: კლასის ტიპის შეზღუდვა '{0}' ყველა დანარჩენ შეზღუდვამდე უნდა იყოს ჩამოთვლილი. ფიქრეთ ტიპის შეზღუდვის შეზღუდვების სიის დასაწყისში გადატანაზე

en: `{0}': cannot specify both a constraint class and the `class' or `struct' constraint
ka: `{0}': ორივეს, შეზღუდვის კლასს და `class' ან `struct' შეზღუდვას, ვერ მიუთითებთ

en: A constraint cannot be special class `{0}'
ka: შეზღუდვა სპეციალური კლასი '{0}' ვერ იქნება

en: A constraint cannot be the dynamic type
ka: შეზღუდვა დინამიკური ტიპის ვერ იქნება

en: `{0}' is not a valid constraint. A constraint must be an interface, a non-sealed class or a type parameter
ka: '{0}' სწორი შეზღუდვა არაა. შეზღუდვა უნდა იყოს ინტერფეისი, არადაბეჭდილი კლასი ან ტიპის პარამეტრი

en: `{0}' is not a valid constraint. Static classes cannot be used as constraints
ka: '{0}' სწორი შეზღუდვა არაა. სტატიკურ კლასებს შეზღუდვებად ვერ გამოიყენებთ

en: The {2} type parameter `{0}' must be {3} valid on `{1}{4}'
ka: {2} ტიპის პარამეტრი `{0}' უნდა იყოს {3} სწორი `{1}{4}-ზე'

en: `{0}': static classes cannot be used as generic arguments
ka: `{0}': სტატიკურ კლასებს ზოგად არგუმენტებად ვერ გამოიყენებთ

en: The type `{0}' may not be used as a type argument
ka: ტიპს '{0}' ტიპის არგუმენტად ვერ გამოიყენებთ

en: Variant type parameters can only be used with interfaces and delegates
ka: ვარიანტის ტიპის პარამეტრები, მხოლოდ, ინტერფესებთან და დელეგატებთან ერთად შეგიძლიათ, გამოიყენოთ

en: Partial method declarations of `{0}' have inconsistent constraints for type parameter `{1}'
ka: '{0}'-ის ნაწილობრივი მეთოდის აღწერას არამდგრადი შეზღუდვები აქვს ტიპის პარამეტრისთვის '{1}'

en: Partial declarations of `{0}' have inconsistent constraints for type parameter `{1}'
ka: '{0}'-ის ნაწილობრივ აღწერას არამდგრადი შეზღუდვები აქვს ტიპის პარამეტრისთვის '{1}'

en: The type `{0}' must be a reference type in order to use it as type parameter `{1}' in the generic type or method `{2}'
ka: ტიპი '{0}' მიმართვის ტიპის უნდა იყოს, რომ გამოიყენოთ, როგორც ტიპის პარამეტრი '{1}' ზოგად ტიპში ან მეთოდში '{2}'

en: The type `{0}' must be a non-nullable value type in order to use it as type parameter `{1}' in the generic type or method `{2}'
ka: ტიპი '{0}' არაგანულებადი მნიშვნელობის ტიპის უნდა იყოს, რომ გამოიყენოთ, როგორც ტიპის პარამეტრი '{1}' ზოგად ტიპში ან მეთოდში '{2}'

en: The type `{0}' must have a public parameterless constructor in order to use it as parameter `{1}' in the generic type or method `{2}'
ka: ტიპს '{0}' უნდა ჰქონდეს საჯარო უპარამეტრო კონსტრუქტორი, რომ გამოიყენოს ის, როგორც პარამეტრი '{1}' ზოგად ტიპში ან მეთოდში '{2}'

en: The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. The nullable type `{0}' never satisfies interface constraint `{3}'
ka: ტიპს '{0}' ვერ გამოიყენებთ ტიპის პარამეტრად '{1}' ზოგად ტიპში ან მეთოდში '{2}'. განულებადი ტიპი '{0}' არასდროს აკმაყოფილებს ინტერფეისის შეზღუდვას '{3}'

en: The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. The nullable type `{0}' does not satisfy constraint `{3}'
ka: ტიპს '{0}' ვერ გამოიყენებთ ტიპის პარამეტრად '{1}' ზოგად ტიპში ან მეთოდში '{2}'. განულებადი ტიპი '{0}' არ აკმაყოფილებს შეზღუდვას '{3}'

en: The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no implicit reference conversion from `{0}' to `{3}'
ka: ტიპს '{0}' ვერ გამოიყენებთ ტიპის პარამეტრად '{1}' ზოგად ტიპში ან მეთოდში '{2}'. არ არსებობს არაცხადი მიმართვის გადაყვანა '{0}'-დან '{3}'-ში

en: The yield statement cannot be used inside anonymous method blocks
ka: გამოსავლის პროცედურას ანონიმური მეთოდის ბლოკების შიგნით ვერ გამოიყენებთ

en: Cannot yield in the body of a finally clause
ka: საბოლოო პირობის ტანში გამოსავალი შეუძლებელია

en: Cannot yield a value in the body of a try block with a catch clause
ka: დაჭერის პირობის მქონე ცდის ბლოკის სხეულში მნიშვნელობის გამოსავალი შეუძლებელია

en: Cannot yield a value in the body of a catch clause
ka: დაჭერის პირობის სხეულში მნიშვნელობის გამოსავალი შეუძლებელია

en: The body of `{0}' cannot be an iterator block because `{1}' is not an iterator interface type
ka: '{0}'-ის სხეული იტერატორის ბლოკი ვერ იქნება, რადგან '{1}' იტერატორის ინტერფეისის ტიპი არაა

en: Iterators cannot have ref or out parameters
ka: იტერატორებს ref ან out პარამეტრები ვერ ექნება

en: __arglist is not allowed in parameter list of iterators
ka: __arglist დაუშვებელია იტერატორის პარამეტრების სიაში

en: Iterators cannot have unsafe parameters or yield types
ka: იტერატორებს სახიფათო პარამეტრები ან შედეგის ტიპები ვერ ექნება

en: SDK path could not be resolved
ka: SDK-ის ბილიკის ამოხსნა შეუძლებელია

en: An assembly with the same name `{0}' has already been imported. Consider removing one of the references or sign the assembly
ka: ანაწყობი იგივე სახელით '{0}' უკვე შემოტანილია. ჯერ წაშალეთ ერთ-ერთი მიმართვა ან ხელი მოაწერეთ ანაწყობს

en: An assembly `{0}' with the same identity has already been imported. Consider removing one of the references
ka: ანაწყობი იგივე სახელით '{0}' უკვე შემოტანილია. ჯერ წაშალეთ ერთ-ერთი მიმართვა

en: An implementation of `{0}' query expression pattern could not be found. Are you missing `System.Linq' using directive or `System.Core.dll' assembly reference?
ka: '{0}' მოთხოვნის გამოსახულების ნიმუშის განხორციელება აღმოჩენილი არაა. შეამოწმეთ, ხომ არ გაკლიათ დირექტივა 'System.Linq'-ის გამოსაყენებლად ან მიმართვა ანაწყობზე 'System.Core.dll'?

en: Query expressions with a source or join sequence of type `dynamic' are not allowed
ka: მოთხოვნის გამოსახულებები წყაროს ან შეერთების მიმდევრობით, ტიპით 'dynamic' დაშვებული არაა

en: Ambiguous implementation of the query pattern `{0}' for source type `{1}'
ka: ბუნდოვანი განხორციელება მოთხოვნის ნიმუშის '{0}' წყაროს ტიპისთვის '{1}'

en: An implementation of `{0}' query expression pattern for source type `{1}' could not be found
ka: '{0}' მოთხოვნის გამოსახულების ნიმუშის განხორციელება წყარო ტიპისთვის '{1}' აღმოჩენილი არაა

en: An expression type is incorrect in a subsequent `from' clause in a query expression with source type `{0}'
ka: გამოსახულების ტიპი არასწორია მომდევნო 'from' პირობაში მოთხოვნის გამოსახულებაში წყაროს ტიპით '{0}'

en: An expression type in `{0}' clause is incorrect. Type inference failed in the call to `{1}'
ka: გამოსახულების ტიპი '{0}' პირობაში არასწორია. ტიპის დასკვნა ჩავარდა '{1}'-ის გამოძახებაში

en: A range variable `{0}' cannot be initialized with `{1}'
ka: შუალედის ცვლადის '{0}' ინიციალიზაცია შეუძლებელია '{1}'-ით

en: A range variable `{0}' conflicts with a previous declaration of `{0}'
ka: შუალედის ცვლადი '{0}' კონფლიქტშია '{0}'-ის წინა აღწერასთან

en: A range variable `{0}' has already been declared in this scope
ka: შუალედის ცვლადი '{0}' უკვე აღწერილია ამ საზღვრებში

en: A range variable `{0}' conflicts with a method type parameter
ka: შუალედის ცვლადი '{0}' გამორიცხავს მეთოდის ტიპის პარამეტრს

en: A range variable `{0}' cannot be assigned to. Consider using `let' clause to store the value
ka: შუალედის ცვლადს '{0}' ვერაფერს მიანიჭებთ. იფიქრეთ 'let' ბრძანების გამოყენებაზე, თუ მნიშვნელობის დამახსოვრება გნებავთ

en: Cannot convert null to the type parameter `{0}' because it could be a value type. Consider using `default ({0})' instead
ka: ნულს ტიპის პარამეტრში '{0}' გადაყვანა შეუძლებელია, რადგან ის, შეიძლება, მნიშვნელობის ტიპი იყოს. იფიქრეთ, გამოიყენოთ 'default ({0})'

en: Cannot convert null to `{0}' because it is a value type
ka: ნულს '{0}'-შ ვერ გადაიყვანთ, რადგან ის მნიშვნელობის ტიპია

en: Literal of type double cannot be implicitly converted to type `{0}'. Add suffix `{1}' to create a literal of this type
ka: ლიტერალს ტიპით double არაცხადად ტიპში '{0}' ვერ გადაიყვანთ. დაამატეთ სუფიქსი '{1}' რომ ამ ტიპის ლიტერალი შექმნათ

en: A partial method declaration and partial method implementation cannot differ on use of `params' modifier
ka: ნაწილობრვი მეთოდის გამოცხადებასა და ნაწილობრივი მეთოდის განხორციელებას, არ შეიძლება, განსხვავებული 'params' მოდიფიკატორს იყენებდნენ

en: A partial method declaration and partial method implementation must be both an extension method or neither
ka: ნაწილობრივი მეთოდის გამოცხადება და ნაწილობრივი მეთოდის განხორციელება ან ორივე გაფართოების მეთოდი უნდა იყოს, ან არცერთი

en: Overloaded contructor `{0}' cannot differ on use of parameter modifiers only
ka: გადამეტტვირთული კონტრუქტორი '{0}' არ შეიძლება განსხვავდებოდეს მხოლოდ, პარამეტრების შემცვლელებით

en: Overloaded method `{0}' cannot differ on use of parameter modifiers only
ka: გადამეტტვირთული მეთოდი '{0}' არ შეიძლება განსხვავდებოდეს მხოლოდ, პარამეტრების შემცვლელებით

en: A partial method declaration and partial method implementation must be both `static' or neither
ka: ნაწილობრივი მეთოდის გამოცხადება და ნაწილობრივი მეთოდის განხორციელება ან ორივე 'static' უნდა იყოს, ან არცერთი

en: A partial method declaration and partial method implementation must be both `unsafe' or neither
ka: ნაწილობრივი მეთოდის გამოცხადება და ნაწილობრივი მეთოდის განხორციელება ან ორივე 'unsafe' უნდა იყოს, ან არცერთი

en: A partial method `{0}' declaration is already defined
ka: ნაწილობრივი მეთოდის '{0}' გამოცხადება უკვე აღწერილია

en: A partial method `{0}' implementation is already defined
ka: ნაწილობრივი მეთოდის '{0}' განხორციელება უკვე აღწერილია

en: A member `{0}' is already reserved
ka: წევრი '{0}' უკვე დარეზერვებულია

en: Duplicate user-defined conversion in type `{0}'
ka: გამეორებული მომხმარებლის აღწერილი გადაყვანა ტიპში '{0}'

en: A member `{0}' is already defined. Rename this member or use different parameter types
ka: წევრი '{0}' უკვე აღწერილია, გადაარქვით სახელი ამ წევრს, ან გამოიყენეთ განსხვავებული პარამეტრის ტიპები

en: `{0}': Async methods cannot use `MethodImplOptions.Synchronized'
ka: `{0}': ასინქრონული მეთოდები `MethodImplOptions.Synchronized'-ს ვერ იყენებენ

en: The DllImport attribute must be specified on a method marked `static' and `extern'
ka: ატრიბუტი DllImport მითითებული უნდა იყოს მეთოდზე, რომელიც დანიშნულია, როგორც 'static' ან 'extern'

en: `{0}': A partial method parameters cannot use `out' modifier
ka: `{0}': ნაწილობრივი მეთოდის პარამეტრები მოდიფიკატორს 'out' ვერ იყენებენ

en: Conditional not valid on `{0}' because it is a constructor, destructor, operator or explicit interface implementation
ka: Conditional არასწორია `{0}'-ზე, რადგან ის კონსტრუქტორი, დესტრუქტორია, ოპერატორი, ან აშკარა ინტერფეისის განხორციელებაა

en: A partial method cannot define access modifier or any of abstract, extern, new, override, sealed, or virtual modifiers
ka: ნაწილობრივი მეთოდი ვერ აღწერს წვდომი მოდიფიკატორს ან მოდფიკატორებით abstract, extern, new, override, sealed ან virtual

en: A partial method must be declared within a partial class or partial struct
ka: ნაწილობრივი მეთოდი ნაწილობრივ კლასში ან ნაწილობრივ სტრუქტურაში უნდა იყოს აღწერილი

en: `{0}': Extension methods must be declared static
ka: `{0}': გაფართოების მეთოდები სტატიკურად უნდა აღწეროთ

en: Program `{0}' has more than one entry point defined: `{1}'
ka: პროგრამას '{0}' ერთზე მეტი შესვლის წერტილი აქვს აღწერილი: '{1}'

en: Conditional not valid on `{0}' because it is an override method
ka: Conditional არასწორია `{0}'-ზე, რადგან ის გადამეტტვირთვის მეთოდია

en: Conditional not valid on `{0}' because its return type is not void
ka: Conditional არასწორია `{0}'-ზე, რადგან მისი დაბრუნების ტიპი ცარიელი არაა

en: Conditional not valid on interface members
ka: პირობა არასწორია ინტერფეისის წევრებზე

en: Conditional member `{0}' cannot implement interface member `{1}'
ka: Conditional-ის წევრს `{0}' არ შეუძლია განახორციელოს ინტერფეისის წევრი `{1}'

en: Conditional method `{0}' cannot have an out parameter
ka: პირობით მეთოდს '{0}' პარამეტრი 'out' ვერ ექნება

en: The constraints for type parameter `{0}' of method `{1}' must match the constraints for type parameter `{2}' of interface method `{3}'. Consider using an explicit interface implementation instead
ka: შეზღუდვები ტიპის პარამეტრისთვის '{0}' მეთოდისთვის '{1}' უნდა ემთხვეოდეს შეზღუდვებს ტიპის პარამეტრისთვის '{2}' ინტერფეისის მეთოდისთვის '{3}'. იფიქრეთ ამის მაგიერ აშკარა ინტერფეისის განხორციელებაზე

en: `{0}': Extension methods cannot be defined in a nested class
ka: `{0}': გაფართოებულ მეთოდებს ერთმანეთში ჩადგმულ კლასში ვერ აღწერთ

en: `{0}': Extension methods require `System.Runtime.CompilerServices.ExtensionAttribute' type to be available. Are you missing an assembly reference?
ka: `{0}': გაფართოები მეთოდებს ხელმისაწვდომობისთვის ტიპი `System.Runtime.CompilerServices.ExtensionAttribute' სჭირდებათ. გამოგრჩათ მიმართვა ანაწყობზე?

en: `{0}': Extension methods must be defined in a non-generic static class
ka: `{0}': გაფართოებები არა-ზოგად სტატიკურ კლასში უნდა იყოს აღწერილი

en: `{0}': an entry point cannot be async method
ka: `{0}': შესვლის წერტილი ასინქრონული მეთოდი ვერ იქნება

en: A partial method `{0}' implementation is missing a partial method declaration
ka: ნაწილობრივი მეთოდის '{0}' განხორციელებას ნაწილობრივი მეთოდის გამოცხადება აკლია

en: The constructor call cannot be dynamically dispatched within constructor initializer
ka: კონსტრუქტორის გამოძახება შეუძლებელია დინამიკურად გაეშვას კონსტრუქტორის ინიციალიზატორში

en: `{0}': Struct constructors cannot call base constructors
ka: `{0}': სტრუქტურის კონსტრუქტორი საბაზისო კონსტრუქტორებს ვერ გამოიძახებს

en: Constructor `{0}' cannot call itself
ka: კონსტრუქტორი '{0}' თავის თავს ვერ გამოიძახებს

en: `{0}': Instance constructor of type with primary constructor must specify `this' constructor initializer
ka: '{0}': ძირითადი კონსტრუქტორის მქონე ტიპის გაშვებული ასლის კონსტრუქტორს 'this' კონსტრუქტორის ინიციალიზატორი უნდა ჰქონდეს

en: `{0}': A class with the ComImport attribute cannot have a user-defined constructor
ka: '{0}': ComImport ატრიბუტის მქონე კლასს მომხმარებლის მიერ აღწერილი კონსტრუქტორი ვერ ექნება

en: `{0}' is an accessor not found in interface member `{1}{2}'
ka: `{0}' აქსესორია, რომელიც აღმოჩენილი არაა ინტერფეისის წევრში `{1}{2}'

en: `{0}.{1}' in explicit interface declaration is not a member of interface
ka: `{0}.{1}' აშკარა ინტერფეისის გამოცხადებაში ინტერფეისის წევრი არაა

en: `{0}' explicit method implementation cannot implement `{1}' because it is an accessor
ka: '{0}' აშკარა მეთოდის განხორციელებას '{1}'-ის განხორციელება არ შეუძლია, რადგან ის აქსესორია

en: Method `{0}' cannot implement interface accessor `{1}'
ka: მეთოდს `{0}' არ შეუძლია განახორციელოს ინტერფეისის აქსესორი `{1}'

en: Accessor `{0}' cannot implement interface member `{1}' for type `{2}'. Use an explicit interface implementation
ka: აქსესორს '{0}' არ შეუძლია, განახორციელოს ინტერფეისის წევრი '{1}' ტიპისთვის '{2}'. გამოიყენეთ აშკარა ინტერფეისის განხორციელება

en: Accessor `{0}' must be declared public to implement interface member `{1}'
ka: აქსესორი '{0}' საჯაროდ უნდა იყოს გამოცხადებული, რომ განახორციელოს ინტერფეისის წევრი '{1}'

en: `{0}': the explicit interface implementation cannot introduce the params modifier
ka: '{0}': ინტერფეისის აშკარა განხორციელება პარამეტრების მოდიფიკატორს ვერ დაამატებს

en: Attribute `{0}' is not valid on property or event accessors. It is valid on `{1}' declarations only
ka: ატრიბუტი '{0}' არასწორია თვისებაზე ან მოვლენის აქსესორებზე. ის, მხოლოდ, '{1}'-ის გამოცხადებებზეა სწორი

en: User-defined operator `{0}' must be declared static and public
ka: მომხმარებლის აღწერილი ოპერატორი '{0}' უნდა იყოს გამოცხადებული, როგორც სტატიკური და საჯარო

en: User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type
ka: მომხმარებლის აღწერილ ოპერატორს არ შეუძლია ობიექტი, რომელიც შემცველი ტიპისაა და გადააკეთოს ის შემცველი ტიპის ობიექტად

en: User-defined conversion must convert to or from the enclosing type
ka: მომხმარებლის აღწერილმა გადაყვანამ ჩასმული ტიპიდან ან ტიპში უნდა გადაიყვანონ

en: User-defined conversion `{0}' cannot convert to or from the dynamic type
ka: მომხმარებლის მიერ აღწერილ გადაყვანას '{0}' დინამიკურ ტიპში ან ტიპიდან გადაყვანა არ შეუძლია

en: User-defined conversion `{0}' cannot convert to or from an interface type
ka: მომხმარებლის მიერ აღწერილ გადაყვანას '{0}' ინტერფეისის ტიპში ან ტიპიდან გადაყვანა არ შეუძლია

en: User-defined conversion `{0}' cannot convert to or from a base class
ka: მომხმარებლის მიერ აღწერილ გადაყვანას '{0}' საბაზისო კლასში ან კლასიდან გადაყვანა არ შეუძლია

en: User-defined conversion `{0}' cannot convert to or from a derived class
ka: მომხმარებლის მიერ აღწერილ გადაყვანას '{0}' მიღებულ კლასში ან კლასიდან გადაყვანა არ შეუძლია

en: The return type for ++ or -- operator must be the containing type or derived from the containing type
ka: ++ ან -- ოპერატორის დაბრუნების ტიპი შემცველი ტიპი უნდა იყოს, ან მიღებული უნდა იყოს შემცველი ტიპიდან

en: The parameter type for ++ or -- operator must be the containing type
ka: პარამეტრის ტიპი ოპერატორისთვის ++ ან -- შემცველი ტიპი უნდა იყოს

en: The parameter type of a unary operator must be the containing type
ka: უნარული ოპერატორის პარამეტრის ტიპი შემცველი ტიპი უნდა იყოს

en: The return type of operator True or False must be bool
ka: ოპერატორის True ან False დაბრუნების ტიპი bool უნდა იყოს

en: One of the parameters of a binary operator must be the containing type
ka: ბინარული ოპერატორის ერთი პარამეტრი შემცველი ტიპის უნდა იყოს

en: The modifier `{0}' is not valid for this item
ka: მოდიფიკატორი '{0}' არასწორია ამ ელემენტისთვის

en: The imported type `{0}' is defined multiple times
ka: შემოტანილი ტიპი '{0}' ერთზე მეტჯერაა აღწერილი

en: A using clause must precede all other namespace elements except extern alias declarations
ka: გამოყენების პირობა გარე ფსევდონიმების აღწერის გარდა ყველა სხვა სახელების სივრცის ელემენტს უნდა უსწრებდეს

en: The using alias `{0}' appeared previously in this namespace
ka: გამოყენების ფსევდონიმი '{0}' ამ სახელების სივრცეში ადრე უკვე გამოჩენილა

en: The namespace `{0}' already contains a definition for `{1}'
ka: სახელების სივრცე '{0}' უკვე შეიცავს აღწერას '{1}'-სთვის

en: Namespace `{0}' contains a definition with same name as alias `{1}'
ka: სახელების სივრცე '{0}' შეიცავს აღწერს იგივე სახელით, როგორც ფსევდონიმს '{1}'

en: The extern alias `{0}' was not specified in -reference option
ka: გარე ფსევდონიმი `{0}' მითითებული არ იყო პარამეტრში -reference

en: An expression tree cannot contain a coalescing operator with null left side
ka: გამოსახულებების ხე არ შეიძლება, მინიჭების ოპერატორს შეიცავდეს ნულით მარცხენა მხარეს

en: The params parameter must be a single dimensional array
ka: პარამეტრი params ერთგანზომილებიანი მასივი უნდა იყოს

en: An out parameter cannot have the `In' attribute
ka: პარამეტრს out არ შეიძლება, 'In' ატრიბუტი ჰქონდეს

en: Do not use `System.ParamArrayAttribute'. Use the `params' keyword instead
ka: არ გამოიყენოთ 'System.ParamArrayAttribute'. მის მაგიერ გამოიყენეთ საკვანძო სიტყვა 'params'

en: Cannot specify only `Out' attribute on a ref parameter. Use both `In' and `Out' attributes or neither
ka: პარამეტრზე 'ref', მხოლოდ, 'Out' ატრიბუტს ვერ მიუთითებთ. გამოიყენეთ ან ორივე ატრიბუტი 'In' და 'Out', ან არც ერთი

en: Cannot specify `{0}' attribute on optional parameter `{1}'
ka: ატრიბუტის '{0}' მითითება შეუძლებელია არასავალდებულო პარამეტრზე '{1}'

en: The CallerMemberName attribute can only be applied to parameters with default value
ka: ატრიბუტი CallerMemberName, მხოლოდ, ნაგულისხმევი მნიშვნელობის მქონე პარამეტრებზე შეგიძლიათ, გამოიყენოთ

en: The CallerLineNumber attribute can only be applied to parameters with default value
ka: ატრიბუტი CallerLineNumber, მხოლოდ, ნაგულისხმევი მნიშვნელობის მქონე პარამეტრებზე შეგიძლიათ, გამოიყენოთ

en: The CallerFilePath attribute can only be applied to parameters with default value
ka: ატრიბუტი CallerFilePath, მხოლოდ, ნაგულისხმევი მნიშვნელობის მქონე პარამეტრებზე შეგიძლიათ, გამოიყენოთ

en: Method or delegate parameter cannot be of type `{0}'
ka: მეთოდი ან დელეგატის პარამეტრი ვერ იქნება ტიპით '{0}'

en: `{0}': static types cannot be used as parameters
ka: `{0}': სტატიკურ ტიპებს პარამეტრებად ვერ გამოიყენებთ

en: The extension method cannot be of type `{0}'
ka: გაფართოების მეთოდი ვერ იქნება ტიპით '{0}'

en: The CallerMemberName attribute cannot be applied because there is no standard conversion from `{0}' to `{1}'
ka: ატრიბუტს CallerMemberName ვერ გადაატარებთ, რადგან '{0}'-დან '{1}'-ში სტანდარტული გადაყვანა არ არსებობს

en: The CallerFilePath attribute cannot be applied because there is no standard conversion from `{0}' to `{1}'
ka: ატრიბუტს CallerFilePath ვერ გადაატარებთ, რადგან '{0}'-დან '{1}'-ში სტანდარტული გადაყვანა არ არსებობს

en: Argument of type `{0}' is not applicable for the DefaultParameterValue attribute
ka: '{0}' ტიპის არგუმენტი გამოუსადეგარია DefaultParameterValue ატრიბუტისთვის

en: The DefaultParameterValue attribute is not applicable on parameters of type `{0}'
ka: ატრიბუტი DefaultParameterValue გამოუსადეგარია '{0}' ტიპის პარამეტრებზე

en: The type of the default value should match the type of the parameter
ka: ნაგულისხმევი მნიშვნელობის ტიპი პარამეტრის ტიპს უნდა ემთხვეოდეს

en: An expression tree parameter cannot use `ref' or `out' modifier
ka: გამოსახულების ხის პარამეტრი 'ref' ან 'out' მოდიფიკატორს ვერ გამოიყენებს

en: The parameter name `{0}' conflicts with a compiler generated name
ka: პარამეტრის სახელი '{0}' კონფლიქტშია კომპილატორის დაგენერირებულ სახელთან

en: The expression being assigned to optional parameter `{0}' must be a constant or default value
ka: გამოსახულებას, რომელსაც არასავალდებულო პარამეტრს '{0}' ანიჭებთ, მუდმივა ან ნაგულისხმევი მნიშვნელობა უნდა იყოს

en: The expression being assigned to nullable optional parameter `{0}' must be default value
ka: გამოსახულება, რომელსაც განულებად არასავალდებულო პარამეტრს '{0}' ანიჭებთ, ნაგულისხმევი მნიშვნელობა უნდა იყოს

en: Optional parameter expression of type `{0}' cannot be converted to parameter type `{1}'
ka: არასავალდებული პარამეტრის გამოსახულებას ტიპით '{0}' ვერ გადაიყვანთ პარამეტრის ტიპში '{1}'

en: Cannot implement interface `{0}' with the specified type parameters because it causes method `{1}' to differ on parameter modifiers only
ka: შეუძლებელია ინტერფეისის '{0}' განხორციელება მითითებული ტიპის პარამეტრებით, რადგან ის აიძულებს მეთოდს '{1}', რომ, მხოლოდ, პარამეტრის მოდიფიკატორებით განსხვავდებოდეს

en: `{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' is static
ka: '{0}' არ ახორციელებს ინტერფეისის წევრს '{1}' და საუკეთესო განმახორციელებელი კანდიდატი '{2}' სტატიკურია

en: `{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' is not public
ka: '{0}' არ ახორციელებს ინტერფეისის წევრს '{1}' და საუკეთესო განმახორციელებელი კანდიდატი '{2}' საჯარო არაა

en: `{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' return type `{3}' does not match interface member return type `{4}'
ka: '{0}' არ ახორციელებს ინტერფეისის წევრს '{1}' და საუკეთესო განმახორციელებელი კანდიდატის '{2}' დაბრუნების ტიპი '{3}' არ ემთხვევა ინტერფეისის წევრის დაბრუნების ტიპს '{4}'

en: `{0}' does not implement interface member `{1}'
ka: `{0}' არ ახორციელებს ინტერფეისის წევრს `{1}'

en: `{0}' does not implement inherited abstract member `{1}'
ka: `{0}' არ ახორციელებს მემკვიდრეობით მიღებულ აბსტრაქტულ წევრს `{1}'

en: `{0}': accessibility modifiers may not be used on accessors in an interface
ka: '{0}': წვდომადობის მოდიფიკატორების ინტერფეისში აქსესორებზე ვერ გამოიყენებთ

en: `{0}': abstract properties cannot have private accessors
ka: `{0}': აბსტრაქტულ თვისებებს არ შეიძლება, პირადი აქსესორები ჰქონდეთ

en: The accessibility modifier of the `{0}' accessor must be more restrictive than the modifier of the property or indexer `{1}'
ka: '{0}' აქსესორის წვდომადობის მოდიფიკატორი უფრო მკაცრი უნდა იყოს, ვიდრე მოდიფიკატორი თვისებისთვის ან ინდექსერისთვის '{1}'

en: Explicit interface implementation `{0}' is missing accessor `{1}'
ka: აშკარა ინტერფეისის განხორციელებას '{0}' აკლია აქსესორი '{1}'

en: `{0}': cannot override because `{1}' does not have an overridable get accessor
ka: `{0}': გადაფარვა შეუძლებელია, რადგან `{1}'-ს გადაფარვადი get აქსესორი არ გააჩნია

en: `{0}': cannot override because `{1}' does not have an overridable set accessor
ka: `{0}': გადაფარვა შეუძლებელია, რადგან `{1}'-ს გადაფარვადი set აქსესორი არ გააჩნია

en: `{0}': Cannot specify accessibility modifiers for both accessors of the property or indexer
ka: '{0}': წვდომადობის მოდიფიკატორების ვერ მიუთითებთ თვისების ან ინდექსერის ორივე აქსესორისთვის

en: `{0}': accessibility modifiers on accessors may only be used if the property or indexer has both a get and a set accessor
ka: '{0}': წვდომადობის მოდიფიკატორების აქსესორებზე, მხოლოდ, მაშინ შეიძლება იყოს გამოყენებული, თუ თვისებას ან ინდექსერს ორივე, set და get აქსესორი გააჩნია

en: Automatically implemented property `{0}' cannot be used inside a type with an explicit StructLayout attribute
ka: ავტომატურად განხორციელებული თვისება '{0}' არ შეიძლება, აშკარა StructLayout ატრიბუტის მქონე ტიპის შიგნით იქნეს გამოყენებული

en: `{0}': event must be of a delegate type
ka: `{0}': მოვლენის ტიპი დელეგატის ტიპი უნდა იყოს

en: The `{0}' attribute is valid only on an indexer that is not an explicit interface member declaration
ka: ატრიბუტი '{0}' სწორია მხოლოდ ინდექსერზე, რომელიც აშკარა ინტერფეისის წევრის გამოცხადება არაა

en: Cannot set the `IndexerName' attribute on an indexer marked override
ka: ატრიბუტის 'IndexerName' დაყენება შეუძლებელია ინდექსერზე, რომელიც მონიშნულია, როგორც გადამეტტვირთული

en: Value specified for the argument to `{0}' is not valid
ka: '{0}'-სთვის არგუმენტად გადაცემული მნიშვნელობა არასწორია

en: A lambda expression with statement body cannot be converted to an expresion tree
ka: ლამბდა გამოსახულებას პროცედურის ტანით გამოსახულებების ხეში ვერ გადაიყვანთ

en: Control cannot leave the body of an anonymous method
ka: კონტროლს არ შუძლია, ანონიმური მეთოდის სხეული დატოვოს

en: Control cannot leave the body of a finally clause
ka: კონტროლს არ შეუძლია, საბოლოო პირობის სხეული დატოვოს

en: An object of a type convertible to `{0}' is required for the return statement
ka: დაბრუნების პროცედურისთვის '{0}'-ში გადაყვანადი ტიპის ობიექტია საჭირო

en: `{0}': A return keyword must not be followed by any expression when method returns void
ka: '{0}': დაბრუნების საკვანძო სიტყვას გამოსახულება არ უნდა მოსდევდეს, როცა მეთოდი სიცარიელეს აბრუნებს

en: `{0}': A return keyword must not be followed by an expression when async method returns `Task'. Consider using `Task<T>' return type
ka: '{0}': საკვანძო სიტყვას return არ უნდა მოჰყვებოდეს გამოსახულება, როცა ასინქრონული მეთოდი აბრუნებს მნიშვნელობას 'Task'. სცადეთ, დაბრუნების ტიპად 'Task<T>' გამოიყენოთ

en: `{0}': The return expression type of async method must be `{1}' rather than `Task<{1}>'
ka: '{0}': ასინქრონული მეთოდის დაბრუნების გამოსახულების ტიპი '{1}' უნდა იყოს და არა 'Task<{1}>'

en: Cannot convert `{0}' to delegate type `{1}' because some of the return types in the block are not implicitly convertible to the delegate return type
ka: '{0}'-ის გადაყვანა დელეგატის ტიპში '{1}' შეუძლებელია, რადგან რამდენიმე დაბრუნების ტიპი ბლოკში არაცხადად არაა გადაყვანადი დელეგატის დაბრუნების ტიპში

en: Cannot return a value from iterators. Use the yield return statement to return a value, or yield break to end the iteration
ka: იტერატორებიდან მნიშვნელობას ვერ დააბრუნებთ. მნიშვნელობის დასაბრუნებლად გამოიყენეთ გამოსავლის დაბრუნების პროცედურა, ან გამოსავლის შეწყვეტა, იტერაციის დასარულებლად

en: The label `{0}:' could not be found within the scope of the goto statement
ka: ჭდე '{0}': აღმოჩენილი არაა goto პროცედურის საზღვრებში

en: A goto case is only valid inside a switch statement
ka: ვარიანტი goto, მხოლოდ, switch პროცედურის შიგნითაა სწორი

en: The type caught or thrown must be derived from System.Exception
ka: დაჭერილი ან გადაგდებული ტიპები System.Exception-დან უნდა იყოს მიღებული

en: A throw statement with no arguments is not allowed outside of a catch clause
ka: პროცედურა throw არგუმენტების გარეშე დაუშვებელია catch პირობის გარეთ

en: A throw statement with no arguments is not allowed inside of a finally clause nested inside of the innermost catch clause
ka: პროცედურა throw არგუმენტების გარეშე დაუშვებელია საბოლოო პირობაში, რომელიც ყველაზე შიდა ჩაჭერის პირობაშია ჩასმული

en: No enclosing loop out of which to break or continue
ka: არ არსებობს დახურული მარყუჟი, რომელიც უნდა შევწყვიტო ან გავაგრძელო

en: A fixed statement cannot use an implicitly typed local variable
ka: ფიქსირებული პროცედურა არაცხადად შეყვანილ ლოკალურ ცვლადს ვერ გამოიყენებს

en: An implicitly typed local variable cannot be a constant
ka: არაცხადად შეყვანილი ლოკალური ცვლადი არ შეიძლება, მუდმივა იყოს

en: An implicitly typed local variable declarator must include an initializer
ka: არაცხადად შეყვანილი ლოკალრი ცვლადის გამომცხადებელი ინიციალიზატორს უნდა შეიცავდეს

en: An implicitly typed local variable declaration cannot include multiple declarators
ka: არაცხადად შეყვანილი ლოკალური ცვლადის გამოცხადება, არ შეიძლება, ერთზე მეტ გამოცხადებას შეიცავდეს

en: A local variable named `{0}' cannot be declared in this scope because it would give a different meaning to `{0}', which is already used in a `{1}' scope to denote something else
ka: ლოკალურ ცვლადს სახელით '{0}' ამ საზღვრებში ვერ გამოაცხადებთ, რადგან სხვა მნიშვნელობას მისცემდა ის '{0}'-ს, რომელიც უკვე გამოიყენება '{1}'-ში რაღაც სხვის გამოსახატად

en: A local variable named `{0}' is already defined in this scope
ka: ლოკალური ცვლადი სახელით '{0}' უკვე აღწერილია ამ საზღვრებში

en: The type parameter name `{0}' is the same as local variable or parameter name
ka: ტიპის პარამეტრის სახელი '{0}' იგივეა, რაც ლოკალური ცვლადის ან პარამეტრის სახელი

en: The out parameter `{0}' must be assigned to before control leaves the current method
ka: გასვლის პარამეტრი '{0}' მანამდე უნდა იყოს მინიჭებული, სანამ კონტროლი მიმდინარე მეთოდს დატოვებს

en: Async methods cannot have ref or out parameters
ka: ასინქრონულ მეთოდებს ref ან out პარამეტრები ვერ ექნებათ

en: __arglist is not allowed in parameter list of async methods
ka: __arglist ასინქრონული მეთოდების პარამეტრების სიაში დაშვებული არაა

en: Async methods cannot have unsafe parameters
ka: ასინქრონულ მეთოდებს სახიფათო პარამეტრები ვერ ექნებათ

en: The label `{0}' is a duplicate
ka: ჭდე '{0}' გამეორებულია

en: The label `{0}' shadows another label by the same name in a contained scope
ka: ჭდე '{0}' ჩრდილავს ხვა ჭდეს იგივე სახელით მის საზღვრებში

en: `{0}': not all code paths return a value
ka: '{0}': ყველა კოდის ბილიკი მნიშვნელობას არ აბრუნებს

en: The label `{0}' already occurs in this switch statement
ka: ჭდე '{0}' უკვე არსებობს ამ გადართვის პროცედურაში

en: Control cannot fall through from one case label `{0}' to another
ka: კონტროლი ერთი შემთხვევის ჭდიდან '{0}' მეორეზე ვერ გადახტება

en: A switch expression of type `{0}' cannot be converted to an integral type, bool, char, string, enum or nullable type
ka: გადართვის გამოსახულება ტიპისთვის '{0}' შეუძლებელია, გადაიყვანოთ ინტეგრალურ ტიპში, bool, char, string, enum ან nullable

en: `{0}' is not a reference type as required by the lock statement
ka: `{0}' არ წარმოადგენს მიმართვის ტიპს, როგორც ამას ჩაკეტვის პროცედურა მოითხოვს

en: The type of locals declared in a fixed statement must be a pointer type
ka: ფიქსირებულ პროცედურაში გამოცხადებული ლოკალურების ტიპი მაჩვენებლის ტიპის უნდა იყოს

en: You cannot use the fixed statement to take the address of an already fixed expression
ka: ფიქსირებულ პროცედურას უკვე ფიქსირებული გამოსახულების მისამართის ასაღებად ვერ გამოიყენებთ

en: The right hand side of a fixed statement assignment may not be a cast expression
ka: ფიქსირებული პროცედურის მინიჭების მარჯვენა მხარე დაკასტვის გამოსახულება ვერ იქნება

en: A previous catch clause already catches all exceptions of this or a super type `{0}'
ka: წინა ჩაჭერის პირობა უკვე იჭერს ყველა გამონაკლისს ამისთვის ან სუპერტიპისთვის {0}''

en: `{0}': type used in a using statement must be implicitly convertible to `System.IDisposable'
ka: '{0}' ტიპი, რომელიც პროცედურაში გამოიყენება, არაპირდაპირად გადაყვანადი უნდა იყოს ტიპში `System.IDisposable'

en: foreach statement requires that the return type `{0}' of `{1}' must have a suitable public MoveNext method and public Current property
ka: პროცედურას foreach ესაჭიროება, რომ '{1}'-ის დაბრუნების ტიპს '{0}' უნდა ჰქონდეს შესაბამისი MoveNext მეთოდი ან საჯარო თვისება Current

en: foreach statement cannot operate on variables of type `{0}' because it contains multiple implementation of `{1}'. Try casting to a specific implementation
ka: პროცედურა foreach ვერ მუშაობს ცვლადებზე ტიპით '{0}', რადგან ის '{1}'-ის ერთზე მეტ განხორციელებას შეიცავს. სცადეთ, მითითებულ განხორციელებაზე დაკასტოთ

en: foreach statement cannot operate on variables of type `{0}' because it does not contain a definition for `{1}' or is inaccessible
ka: პროცედურა foreach ვერ მუშაობს ცვლადებზე ტიპით '{0}', რადგან ის არ შეიცავს აღწერას '{1}'-სთვის ან ხელმიუწვდომელია

en: Use of null is not valid in this context
ka: ნულის გამოყენება არასწორია ამ კონტექსტში

en: Foreach statement cannot operate on a `{0}'
ka: პროცედურა Foreach ვერ მუშაობს '{0}'-ზე

en: The predefined type `{0}.{1}' is not defined or imported
ka: წინასწარ აღწერილი ტიპი `{0}.{1}' არც აღწერილია, არც შემოტანილი

en: The predefined type `{0}.{1}' is defined multiple times. Using definition from `{2}'
ka: წინასწარ აღწერილი ტიპი '{0}.{1}' ერთზე მეტჯერაა აღწერილი. გამოიყენება აღწერა '{2}'-დან

en: The predefined type `{0}.{1}' is defined in an assembly that is not referenced.
ka: წინასწარ აღწერილი ტიპი `{0}.{1}' აღწერილია ანაწყობში, რომელზეც მიმართვა არ ხდება.

en: The predefined type `{0}.{1}' is not declared correctly
ka: წინასწარ აღწერილი ტიპი `{0}.{1}' არასწორადაა აღწერილი

en: The compiler required member `{0}.{1}{2}' could not be found or is inaccessible
ka: კომპილატორს სჭირდება წევრი `{0}.{1}{2}', რომელიც აღმოჩენილი არაა ან ხელმიუწვდომელია

en: Cannot take the address of, get the size of, or declare a pointer to a managed type `{0}'
ka: ვერ აიღებთ მისამართს, მიიღებთ ზომას ან აღწერთ მაჩვენებელს მართული ტიპით '{0}'
