CultureInfo Sınıf

Tanım

Belirli bir kültür hakkında bilgi sağlar (yönetilmeyen kod geliştirme için yerel ayar olarak adlandırılır).Provides information about a specific culture (called a locale for unmanaged code development). Bilgiler kültür, yazma sistemi, kullanılan takvim, dizelerin sıralama düzeni ve Tarih ve sayı için biçimlendirme içerir.The information includes the names for the culture, the writing system, the calendar used, the sort order of strings, and formatting for dates and numbers.

public ref class CultureInfo : ICloneable, IFormatProvider
public class CultureInfo : ICloneable, IFormatProvider
[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
Public Class CultureInfo
Implements ICloneable, IFormatProvider
Devralma
CultureInfo
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnek, International sıralaması ve geleneksel sıralamaya sahip başka bir CultureInfo nesnesi ile Ispanyolca (Ispanya) için bir CultureInfo nesnesinin nasıl oluşturulacağını gösterir.The following example shows how to create a CultureInfo object for Spanish (Spain) with the international sort and another CultureInfo object with the traditional sort.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
int main()
{
   
   // Creates and initializes the CultureInfo which uses the international sort.
   CultureInfo^ myCIintl = gcnew CultureInfo( "es-ES",false );
   
   // Creates and initializes the CultureInfo which uses the traditional sort.
   CultureInfo^ myCItrad = gcnew CultureInfo( 0x040A,false );
   
   // Displays the properties of each culture.
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "PROPERTY", "INTERNATIONAL", "TRADITIONAL" );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "CompareInfo", myCIintl->CompareInfo, myCItrad->CompareInfo );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "DisplayName", myCIintl->DisplayName, myCItrad->DisplayName );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "EnglishName", myCIintl->EnglishName, myCItrad->EnglishName );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "IsNeutralCulture", myCIintl->IsNeutralCulture, myCItrad->IsNeutralCulture );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "IsReadOnly", myCIintl->IsReadOnly, myCItrad->IsReadOnly );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "LCID", myCIintl->LCID, myCItrad->LCID );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "Name", myCIintl->Name, myCItrad->Name );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "NativeName", myCIintl->NativeName, myCItrad->NativeName );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "Parent", myCIintl->Parent, myCItrad->Parent );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "TextInfo", myCIintl->TextInfo, myCItrad->TextInfo );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "ThreeLetterISOLanguageName", myCIintl->ThreeLetterISOLanguageName, myCItrad->ThreeLetterISOLanguageName );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "ThreeLetterWindowsLanguageName", myCIintl->ThreeLetterWindowsLanguageName, myCItrad->ThreeLetterWindowsLanguageName );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "TwoLetterISOLanguageName", myCIintl->TwoLetterISOLanguageName, myCItrad->TwoLetterISOLanguageName );
   Console::WriteLine();
   
   // Compare two strings using myCIintl -> 
   Console::WriteLine( "Comparing \"llegar\" and \"lugar\"" );
   Console::WriteLine( "   With myCIintl -> CompareInfo -> Compare: {0}", myCIintl->CompareInfo->Compare( "llegar", "lugar" ) );
   Console::WriteLine( "   With myCItrad -> CompareInfo -> Compare: {0}", myCItrad->CompareInfo->Compare( "llegar", "lugar" ) );
}

/*
This code produces the following output.

PROPERTY                       INTERNATIONAL                                  TRADITIONAL              
CompareInfo                    CompareInfo - es-ES                            CompareInfo - es-ES_tradnl
DisplayName                    Spanish (Spain)                                Spanish (Spain)          
EnglishName                    Spanish (Spain, International Sort)            Spanish (Spain, Traditional Sort)
IsNeutralCulture               False                                          False                    
IsReadOnly                     False                                          False                    
LCID                           3082                                           1034                     
Name                           es-ES                                          es-ES                    
NativeName                     Español (España, alfabetización internacional) Español (España, alfabetización tradicional)
Parent                         es                                             es                       
TextInfo                       TextInfo - es-ES                               TextInfo - es-ES_tradnl  
ThreeLetterISOLanguageName     spa                                            spa                      
ThreeLetterWindowsLanguageName ESN                                            ESP                      
TwoLetterISOLanguageName       es                                             es                       

Comparing "llegar" and "lugar"
   With myCIintl -> CompareInfo -> Compare: -1
   With myCItrad -> CompareInfo -> Compare: 1

*/
using System;
using System.Collections;
using System.Globalization;

public class SamplesCultureInfo
{

   public static void Main()
   {

      // Creates and initializes the CultureInfo which uses the international sort.
      CultureInfo myCIintl = new CultureInfo("es-ES", false);

      // Creates and initializes the CultureInfo which uses the traditional sort.
      CultureInfo myCItrad = new CultureInfo(0x040A, false);

      // Displays the properties of each culture.
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "PROPERTY", "INTERNATIONAL", "TRADITIONAL");
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "CompareInfo", myCIintl.CompareInfo, myCItrad.CompareInfo);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "DisplayName", myCIintl.DisplayName, myCItrad.DisplayName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "EnglishName", myCIintl.EnglishName, myCItrad.EnglishName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsNeutralCulture", myCIintl.IsNeutralCulture, myCItrad.IsNeutralCulture);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsReadOnly", myCIintl.IsReadOnly, myCItrad.IsReadOnly);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "LCID", myCIintl.LCID, myCItrad.LCID);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Name", myCIintl.Name, myCItrad.Name);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "NativeName", myCIintl.NativeName, myCItrad.NativeName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Parent", myCIintl.Parent, myCItrad.Parent);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TextInfo", myCIintl.TextInfo, myCItrad.TextInfo);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterISOLanguageName", myCIintl.ThreeLetterISOLanguageName, myCItrad.ThreeLetterISOLanguageName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterWindowsLanguageName", myCIintl.ThreeLetterWindowsLanguageName, myCItrad.ThreeLetterWindowsLanguageName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TwoLetterISOLanguageName", myCIintl.TwoLetterISOLanguageName, myCItrad.TwoLetterISOLanguageName);
      Console.WriteLine();

      // Compare two strings using myCIintl.
      Console.WriteLine("Comparing \"llegar\" and \"lugar\"");
      Console.WriteLine("   With myCIintl.CompareInfo.Compare: {0}", myCIintl.CompareInfo.Compare("llegar", "lugar"));
      Console.WriteLine("   With myCItrad.CompareInfo.Compare: {0}", myCItrad.CompareInfo.Compare("llegar", "lugar"));
   }
}

/*
This code produces the following output.

PROPERTY                       INTERNATIONAL                                  TRADITIONAL              
CompareInfo                    CompareInfo - es-ES                            CompareInfo - es-ES_tradnl
DisplayName                    Spanish (Spain)                                Spanish (Spain)          
EnglishName                    Spanish (Spain, International Sort)            Spanish (Spain, Traditional Sort)
IsNeutralCulture               False                                          False                    
IsReadOnly                     False                                          False                    
LCID                           3082                                           1034                     
Name                           es-ES                                          es-ES                    
NativeName                     Español (España, alfabetización internacional) Español (España, alfabetización tradicional)
Parent                         es                                             es                       
TextInfo                       TextInfo - es-ES                               TextInfo - es-ES_tradnl  
ThreeLetterISOLanguageName     spa                                            spa                      
ThreeLetterWindowsLanguageName ESN                                            ESP                      
TwoLetterISOLanguageName       es                                             es                       

Comparing "llegar" and "lugar"
   With myCIintl.CompareInfo.Compare: -1
   With myCItrad.CompareInfo.Compare: 1

*/
Imports System.Collections
Imports System.Globalization

Module Module1

    Public Sub Main()

        ' Creates and initializes the CultureInfo which uses the international sort.
        Dim myCIintl As New CultureInfo("es-ES", False)

        ' Creates and initializes the CultureInfo which uses the traditional sort.
        Dim myCItrad As New CultureInfo(&H40A, False)

        ' Displays the properties of each culture.
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "PROPERTY", "INTERNATIONAL", "TRADITIONAL")
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "CompareInfo", myCIintl.CompareInfo, myCItrad.CompareInfo)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "DisplayName", myCIintl.DisplayName, myCItrad.DisplayName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "EnglishName", myCIintl.EnglishName, myCItrad.EnglishName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsNeutralCulture", myCIintl.IsNeutralCulture, myCItrad.IsNeutralCulture)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsReadOnly", myCIintl.IsReadOnly, myCItrad.IsReadOnly)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "LCID", myCIintl.LCID, myCItrad.LCID)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Name", myCIintl.Name, myCItrad.Name)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "NativeName", myCIintl.NativeName, myCItrad.NativeName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Parent", myCIintl.Parent, myCItrad.Parent)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TextInfo", myCIintl.TextInfo, myCItrad.TextInfo)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterISOLanguageName", myCIintl.ThreeLetterISOLanguageName, myCItrad.ThreeLetterISOLanguageName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterWindowsLanguageName", myCIintl.ThreeLetterWindowsLanguageName, myCItrad.ThreeLetterWindowsLanguageName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TwoLetterISOLanguageName", myCIintl.TwoLetterISOLanguageName, myCItrad.TwoLetterISOLanguageName)
        Console.WriteLine()

        ' Compare two strings using myCIintl.
        Console.WriteLine("Comparing ""llegar"" and ""lugar""")
        Console.WriteLine("   With myCIintl.CompareInfo.Compare: {0}", myCIintl.CompareInfo.Compare("llegar", "lugar"))
        Console.WriteLine("   With myCItrad.CompareInfo.Compare: {0}", myCItrad.CompareInfo.Compare("llegar", "lugar"))

    End Sub



'This code produces the following output.
'
'PROPERTY                       INTERNATIONAL                                  TRADITIONAL              
'CompareInfo                    CompareInfo - es-ES                            CompareInfo - es-ES_tradnl
'DisplayName                    Spanish (Spain)                                Spanish (Spain)          
'EnglishName                    Spanish (Spain, International Sort)            Spanish (Spain, Traditional Sort)
'IsNeutralCulture               False                                          False                    
'IsReadOnly                     False                                          False                    
'LCID                           3082                                           1034                     
'Name                           es-ES                                          es-ES                    
'NativeName                     Español (España, alfabetización internacional) Español (España, alfabetización tradicional)
'Parent                         es                                             es                       
'TextInfo                       TextInfo - es-ES                               TextInfo - es-ES_tradnl  
'ThreeLetterISOLanguageName     spa                                            spa                      
'ThreeLetterWindowsLanguageName ESN                                            ESP                      
'TwoLetterISOLanguageName       es                                             es                       
'
'Comparing "llegar" and "lugar"
'   With myCIintl.CompareInfo.Compare: -1
'   With myCItrad.CompareInfo.Compare: 1

End Module

Açıklamalar

CultureInfo sınıfı, belirli bir kültür ile ilişkili dil, alt dil, ülke/bölge, takvim ve kurallar gibi kültüre özgü bilgiler sağlar.The CultureInfo class provides culture-specific information, such as the language, sublanguage, country/region, calendar, and conventions associated with a particular culture. Bu sınıf Ayrıca DateTimeFormatInfo, NumberFormatInfo, CompareInfove TextInfo nesnelerinin kültüre özgü örneklerine erişim sağlar.This class also provides access to culture-specific instances of the DateTimeFormatInfo, NumberFormatInfo, CompareInfo, and TextInfo objects. Bu nesneler, büyük/küçük harf, tarih ve sayı biçimlendirme ve dizeleri karşılaştırma gibi kültüre özgü işlemler için gereken bilgileri içerir.These objects contain the information required for culture-specific operations, such as casing, formatting dates and numbers, and comparing strings. CultureInfo sınıfı, String, DateTime, DateTimeOffsetve sayısal türler gibi kültüre özgü verileri biçimleyerek, ayrıştırarak ya da işleyen sınıflar tarafından doğrudan veya dolaylı olarak kullanılır.The CultureInfo class is used either directly or indirectly by classes that format, parse, or manipulate culture-specific data, such as String, DateTime, DateTimeOffset, and the numeric types.

Bu bölümde:In this section:

Kültür adları ve tanımlayıcıları Culture names and identifiers
Sabit, nötr ve belirli kültürler Invariant, neutral, and specific cultures
Özel kültürler Custom cultures
Dinamik kültür verileri Dynamic culture data
Geçerli kültür ve geçerli kullanıcı arabirimi kültürüne sahip CultureInfo ve kültürel verileri CultureInfo and cultural data The current culture and current UI culture
Tüm kültürleri alma Getting all cultures
Kültür ve iş parçacıkları Culture and threads
Kültür ve uygulama etki alanları Culture and application domains
Kültür ve görev tabanlı zaman uyumsuz işlemler Culture and task-based asynchronous operations
CultureInfo nesne serileştirme CultureInfo object serialization
Denetim Masası geçersiz kılmaları Control Panel overrides
Alternatif sıralama düzenleri Alternate sort orders
Kültür ve Windows uygulamalarıCulture and Windows apps

Kültür adları ve tanımlayıcılarıCulture names and identifiers

CultureInfo sınıfı, RFC 4646 ' ye göre her kültür için benzersiz bir ad belirtir.The CultureInfo class specifies a unique name for each culture, based on RFC 4646. Ad, bir dille ilişkili ISO 639 2 harfli küçük harfli bir kültür kodu ve bir ülke veya bölgeyle ilişkili bir ISO 3166 2-Letter büyük harf alt kültür kodu birleşimidir.The name is a combination of an ISO 639 two-letter lowercase culture code associated with a language and an ISO 3166 two-letter uppercase subculture code associated with a country or region. Ayrıca, .NET Framework 4.NET Framework 4 ve üstünü hedefleyen ve Windows 10 veya üzeri sürümlerde çalışan uygulamalar için, geçerli BCP-47 dil etiketlerine karşılık gelen kültür adları desteklenir.In addition, for apps that target .NET Framework 4.NET Framework 4 or later and are running under Windows 10 or later, culture names that correspond to valid BCP-47 language tags are supported.

Not

Bir kültür adı bir sınıf oluşturucusuna veya CreateSpecificCulture ya da CultureInfogibi bir yönteme geçirildiğinde, büyük/küçük harf durumu önemli değildir.When a culture name is passed to a class constructor or a method such as CreateSpecificCulture or CultureInfo, its case is not significant.

RFC 4646 ' a dayalı kültür adı biçimi languagecode2>-Country/regioncode2, burada languagecode2 iki harfli dil kodu ve Ülke/regioncode2 ise iki harfli alt kültür kodudur.The format for the culture name based on RFC 4646 is languagecode2>-country/regioncode2, where languagecode2 is the two-letter language code and country/regioncode2 is the two-letter subculture code. Japonca (Japonya) için ja-JP ve Ingilizce (Birleşik Devletler) için en-US sayılabilir.Examples include ja-JP for Japanese (Japan) and en-US for English (United States). İki harfli dil kodunun kullanılamadığı durumlarda ISO 639-2 ' den türetilen üç harfli bir kod kullanılır.In cases where a two-letter language code is not available, a three-letter code derived from ISO 639-2 is used.

Bazı kültür adları ISO 15924 betiği de belirtdiğine unutmayın.Note that some culture names also specify an ISO 15924 script. Örneğin, Cyrl, Kiril betiğini belirtir ve Latn Latin betiğini belirtir.For example, Cyrl specifies the Cyrillic script and Latn specifies the Latin script. Bir betik içeren bir kültür adı, languagecode2-scripttag-Country/regioncode2' ını kullanır.A culture name that includes a script uses the pattern languagecode2-scripttag-country/regioncode2. Bu tür kültür adına bir örnek, Özbekçe (Kiril, Özbekistan) için uz-Cyrl-UZ ' dir.An example of this type of culture name is uz-Cyrl-UZ for Uzbek (Cyrillic, Uzbekistan). Windows Vista 'Dan önceki Windows işletim sistemlerinde, bir betiği içeren bir kültür adı, languagecode2-country/regioncode2-scripttag, örneğin, Özbekçe (Kiril, Özbekistan) Için uz-uz-Cyrl kullanır.On Windows operating systems before Windows Vista, a culture name that includes a script uses the pattern languagecode2-country/regioncode2-scripttag, for example, uz-UZ-Cyrl for Uzbek (Cyrillic, Uzbekistan).

Nötr kültür yalnızca iki harfli küçük harfli dil kodu ile belirtilir.A neutral culture is specified by only the two-letter lowercase language code. Örneğin, fr, Fransızca için nötr kültürü belirtir ve de Almanca için nötr kültürü belirtir.For example, fr specifies the neutral culture for French, and de specifies the neutral culture for German.

Not

Bu kuralla çakışan iki kültür adı vardır.There are two culture names that contradict this rule. Zh-Hant adlı zh-Hans ve Çince (Geleneksel) olarak adlandırılan kültürler, nötr kültürler.The cultures Chinese (Simplified), named zh-Hans, and Chinese (Traditional), named zh-Hant, are neutral cultures. Kültür adları geçerli standardı temsil eder ve daha eski olan zh-CHS ve zh-CHT adlarını kullanma nedeniniz yoksa kullanılmalıdır.The culture names represent the current standard and should be used unless you have a reason for using the older names zh-CHS and zh-CHT.

Kültür tanımlayıcısı standart bir uluslararası sayısal kısaltmadır ve yüklü kültürlerin birini benzersiz bir şekilde tanımlamak için gerekli bileşenleri içerir.A culture identifier is a standard international numeric abbreviation and has the components necessary to uniquely identify one of the installed cultures. Uygulamanız, önceden tanımlanmış kültür tanımlayıcılarını kullanabilir veya özel tanımlayıcılar tanımlayabilir.Your application can use predefined culture identifiers or define custom identifiers.

Bazı önceden tanımlanmış kültür adları ve tanımlayıcıları, System.Globalization ad alanındaki bu ve diğer sınıflar tarafından kullanılır.Certain predefined culture names and identifiers are used by this and other classes in the System.Globalization namespace. Windows sistemlerine yönelik ayrıntılı kültür bilgileri için, Windows tarafından desteklenen dil/bölge adları listesindeki Dil etiketi sütununa bakın.For detailed culture information for Windows systems, see the Language tag column in the list of language/region names supported by Windows. Kültür adları BCP 47tarafından tanımlanan standardı izler.Culture names follow the standard defined by BCP 47.

Kültür adlarının ve tanımlayıcıların yalnızca belirli bir bilgisayarda bulunan kültürlerin bir alt kümesini temsil ettiğini unutmayın.Remember that the culture names and identifiers represent only a subset of cultures that can be found on a particular computer. Windows sürümleri veya hizmet paketleri kullanılabilir kültürleri değiştirebilir.Windows versions or service packs can change the available cultures. Uygulamalar CultureAndRegionInfoBuilder sınıfını kullanarak özel kültürler ekler.Applications add custom cultures using the CultureAndRegionInfoBuilder class. Kullanıcılar, Microsoft Locale Builder aracını kullanarak kendi özel kültürlerini ekler.Users add their own custom cultures using the Microsoft Locale Builder tool. Microsoft Locale Builder, CultureAndRegionInfoBuilder sınıfını kullanarak yönetilen kodda yazılır.Microsoft Locale Builder is written in managed code using the CultureAndRegionInfoBuilder class.

Birçok farklı ad, özellikle aşağıdaki sınıf üyeleriyle ilişkili adlar olan bir kültür ile yakından ilişkilendirilir:Several distinct names are closely associated with a culture, notably the names associated with the following class members:

Sabit, nötr ve belirli kültürlerInvariant, neutral, and specific cultures

Kültürler genellikle üç küme halinde gruplandırılır: sabit kültürler, nötr kültürler ve belirli kültürler.The cultures are generally grouped into three sets: invariant cultures, neutral cultures, and specific cultures.

Sabit kültür kültür duyarsızdır.An invariant culture is culture-insensitive. Uygulamanız, boş bir dize ("") veya kendi tanımlayıcısına göre sabit kültür adını belirtir.Your application specifies the invariant culture by name using an empty string ("") or by its identifier. InvariantCulture, sabit kültürün bir örneğini tanımlar.InvariantCulture defines an instance of the invariant culture. Bu, herhangi bir ülkede/bölgede değil, Ingilizce diliyle ilişkilidir.It is associated with the English language but not with any country/region. Kültür gerektiren Globalization ad alanındaki neredeyse her yöntemde kullanılır.It is used in almost any method in the Globalization namespace that requires a culture.

Nötr kültür, bir dille ilişkili ancak ülke/bölge içermeyen bir kültürdür.A neutral culture is a culture that is associated with a language but not with a country/region. Belirli bir kültür, bir dil ve ülke/bölge ile ilişkili bir kültürdür.A specific culture is a culture that is associated with a language and a country/region. Örneğin, fr, Fransızca kültür için nötr addır ve fr-FR, belirli Fransızca (Fransa) kültürünün adıdır.For example, fr is the neutral name for the French culture, and fr-FR is the name of the specific French (France) culture. Çince (Basitleştirilmiş) ve Çince (Geleneksel) 'nin de nötr kültürler kabul edileceğini unutmayın.Note that Chinese (Simplified) and Chinese (Traditional) are also considered neutral cultures.

Bağımsız kültür için CompareInfo sınıfının bir örneğini oluşturmak önerilmez çünkü içerdiği veriler rastgele.Creating an instance of a CompareInfo class for a neutral culture is not recommended because the data it contains is arbitrary. Verileri göstermek ve sıralamak için hem dili hem de bölgeyi belirtin.To display and sort data, specify both the language and region. Ayrıca, nötr kültür için oluşturulan bir CompareInfo nesnesinin Name özelliği yalnızca ülkeyi döndürür ve bölgeyi içermez.Additionally, the Name property of a CompareInfo object created for a neutral culture returns only the country and does not include the region.

Tanımlı kültürler, belirli bir kültürün üst öğesinin bağımsız bir kültür olduğu ve nötr kültürün üst öğesi sabit kültür olduğu bir hiyerarşiye sahiptir.The defined cultures have a hierarchy in which the parent of a specific culture is a neutral culture and the parent of a neutral culture is the invariant culture. Parent özelliği, belirli bir kültür ile ilişkili nötr kültürü içerir.The Parent property contains the neutral culture associated with a specific culture. Özel kültürler, bu düzenle uyum içinde Parent özelliğini tanımlamalıdır.Custom cultures should define the Parent property in conformance with this pattern.

Belirli bir kültürün kaynakları işletim sisteminde yoksa, ilişkili nötr kültürün kaynakları kullanılır.If the resources for a specific culture are not available in the operating system, the resources for the associated neutral culture are used. Nötr kültürün kaynakları kullanılamıyorsa, ana derlemede gömülü kaynaklar kullanılır.If the resources for the neutral culture are not available, the resources embedded in the main assembly are used. Kaynak geri dönüş işlemi hakkında daha fazla bilgi için bkz. kaynakları paketleme ve dağıtma.For more information on the resource fallback process, see Packaging and Deploying Resources.

Windows API 'sindeki yerel ayarların listesi, .NET Framework tarafından desteklenen kültürlerin listesinden biraz farklıdır.The list of locales in the Windows API is slightly different from the list of cultures supported by the .NET Framework. Örneğin, p/Invoke mekanizması aracılığıyla Windows ile birlikte çalışabilirlik gerekliyse, uygulamanın işletim sistemi için tanımlanan belirli bir kültür kullanması gerekir.If interoperability with Windows is required, for example, through the p/invoke mechanism, the application should use a specific culture that is defined for the operating system. Belirli kültürün kullanımı, LCIDile aynı bir yerel ayar tanımlayıcısı ile tanımlanan eşdeğer Windows yerel ayarıyla tutarlılığı sağlar.Use of the specific culture ensures consistency with the equivalent Windows locale, which is identified with a locale identifier that is the same as LCID.

DateTimeFormatInfo veya NumberFormatInfo yalnızca sabit kültür için veya belirli kültürler için oluşturulabilir, nötr kültürler için değil.A DateTimeFormatInfo or a NumberFormatInfo can be created only for the invariant culture or for specific cultures, not for neutral cultures.

DateTimeFormatInfo.Calendar TaiwanCalendar, ancak Thread.CurrentCulture zh-TW olarak ayarlanmamışsa, DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraNameve DateTimeFormatInfo.GetAbbreviatedEraName boş bir dize ("") döndürür.If DateTimeFormatInfo.Calendar is the TaiwanCalendar but the Thread.CurrentCulture is not set to zh-TW, then DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraName, and DateTimeFormatInfo.GetAbbreviatedEraName return an empty string ("").

Özel kültürlerCustom cultures

Windows işletim sistemi ve .NET Framework tarafından desteklenen önceden tanımlı kültürlere ek olarak, .NET Framework üç tür özel kültürü destekler:In addition to the predefined cultures supported by the Windows operating system and the .NET Framework, the .NET Framework supports three types of custom cultures:

  • Windows veya .NET Framework bulunan kültürleri tamamlayan yeni kültürler.New cultures that supplement the cultures available in Windows or the .NET Framework. Örneğin, bir uygulama bir sistemde FJ-FJ (veya Fijan (Fiji)) kültürünü temsil eden bir CultureInfo nesnesi kurabilir.For example, an application could install a CultureInfo object that represents the fj-FJ (or Fijan (Fiji)) culture on a system.

  • Özellikleri Windows ve .NET Framework tarafından desteklenen standart kültürlerin özelliklerinden farklı olan değiştirme kültürleri.Replacement cultures whose properties are different from the properties of the standard cultures supported by Windows and the .NET Framework.

  • Kullanıcı geçersiz kılmalarla standart kültürler.Standard cultures with user overrides. Kullanıcı, var olan bir kültürün özellik değerlerini özelleştirmek için Denetim Masası 'ndaki bölge ve dil uygulamasını kullanabilir.The user can use the Region and Language application in Control Panel to customize an existing culture's property values.

Not

Mevcut kültürleri tamamlayan veya değiştirecek özel kültürleri tanımlamak, kaydetmek ve kaydetmek için CultureAndRegionInfoBuilder sınıfını kullanabilirsiniz.You can use the CultureAndRegionInfoBuilder class to define, save, and register custom cultures that either supplement or replace existing cultures. CultureAndRegionInfoBuilder.Save yöntemi, hedef sistemlere özel bir kültür yüklemek için kullanılabilecek bir yerel ayar veri biçimlendirme dili (LDML) dosyası oluşturur.The CultureAndRegionInfoBuilder.Save method creates a Locale Data Markup Language (LDML) file that can be used to install a custom culture on target systems. Yeni veya değiştirme kültürü oluşturmak için CultureAndRegionInfoBuilder sınıfını kullanma hakkında adım adım bilgiler için CultureAndRegionInfoBuilder sınıfı konusuna bakın.For step-by step information on using the CultureAndRegionInfoBuilder class to create a new or replacement culture, see the CultureAndRegionInfoBuilder class topic.

.NET Framework özel kültürleri desteklediğinden, kültüre özgü verilerle çalışırken aşağıdakileri göz önünde bulundurmanız gerekir:Because the .NET Framework supports custom cultures, you should consider the following when working with culture-specific data:

  • Özel kültürler, önceden tanımlanmış kültürlerin aralıklarını aşan değerlere sahip olabilir.Custom cultures can have values that exceed the ranges of the predefined cultures. Örneğin, bazı kültürler olağandışı olarak uzun ay adlarına, beklenmedik tarih veya saat biçimlerine veya diğer olağandışı verilere sahiptir.For example, some cultures have unusually long month names, unexpected date or time formats, or other unusual data.

  • Kullanıcı arabiriminde kültüre özgü verileri görüntülediğinizde kullanıcının özelleştirmelerini dikkate almalısınız; Örneğin, Kullanıcı 24 saatlik bir saat veya yyyyMMdd tarih biçimi isteyebilir.When you display culture-specific data in the user interface, you should respect the user's customizations; for example, the user might want a 24-hour clock or a yyyyMMdd date format.

  • Özel kültürlerin varsayılan değerleri geçersiz kılmasını unutmayın.Remember that custom cultures override default values. Bu nedenle, kültür verilerinin kararlı bir şekilde kabul edilemez.Therefore, you cannot consider culture data to be stable. Ülke adları, sayı ve tarih biçimleri ve daha sonra yazımlar değişebilir.Country names, number and date formats, and spellings may change in the future. Tarih ve saat dizeleri gibi kültüre duyarlı verileri, tarih ve saat ayrıştırma işlevlerine geçirilecek şekilde seri hale getirmek istiyorsanız, sabit kültür veya belirli bir kullanın.If you want to serialize culture-sensitive data such as date and time strings to be passed to the date and time parsing functions, you should use the invariant culture or a specific .

Bir sistemde yüklü olan özel kültürlerin CultureTypes Özellik değeri System.Globalization.CultureTypes bayrağını içerir ve özel kültürler LOCALE_CUSTOM_UNSPECIFIED (0x1000 veya 4096) LCID özellik değerine atanır.The CultureTypes property value of custom cultures installed on a system includes the System.Globalization.CultureTypes flag, and custom cultures are assigned an LCID property value of LOCALE_CUSTOM_UNSPECIFIED (0x1000, or 4096). Windows 10 ' dan itibaren, bu değer ayrıca tam kültürel verileri olmayan sistem tarafından tanımlanan kültürlere de atandığını unutmayın.Note that, starting with Windows 10, this value is also assigned to system-defined cultures that lack complete cultural data.

CultureInfo ve kültürel verileriCultureInfo and cultural data

.NET, uygulama, platform ve sürüme bağlı olarak çeşitli kaynaklardan birinden kültürel verilerini türetiliyor:.NET derives its cultural data from a one of a variety of sources, depending on implementation, platform, and version:

  • .NET Framework 3,5 ve önceki sürümlerde, kültürel verileri hem Windows işletim sistemi hem de .NET Framework tarafından sağlanır.In .NET Framework 3.5 and earlier versions, cultural data is provided by both the Windows operating system and the .NET Framework.

  • .NET Framework 4 ve sonraki sürümlerde, kültürel verileri Windows işletim sistemi tarafından sağlanır.In .NET Framework 4 and later versions, cultural data is provided by the Windows operating system.

  • .NET Core 'un Windows üzerinde çalışan tüm sürümlerinde, kültürel verileri Windows işletim sistemi tarafından sağlanır.In all versions of .NET Core running on Windows, cultural data is provided by the Windows operating system.

  • .NET Core 'un UNIX platformlarında çalışan tüm sürümlerinde, kültürel verileri Unicode (ıCU) kitaplığı Için Uluslararası bileşenlertarafından sağlanır.In all versions of .NET Core running on Unix platforms, cultural data is provided by the International Components for Unicode (ICU) Library. ICU kitaplığının belirli sürümü ayrı işletim sistemine bağlıdır.The specific version of the ICU Library depends on the individual operating system.

Bu nedenle, belirli bir .NET uygulamasında, platformda veya sürümünde kullanılabilen bir kültür, farklı bir .NET uygulamasında, platformda veya sürümünde bulunmayabilir.Because of this, a culture available on a particular .NET implementation, platform, or version may not be available on a different .NET implementation, platform, or version.

Bazı CultureInfo nesneleri, temel alınan platforma bağlı olarak farklılık gösterir.Some CultureInfo objects differ depending on the underlying platform. Özellikle, "zh-CN" veya Çince (Basitleştirilmiş, Çin) ve zh-TW veya Çince (geleneksel, Tayvan), Windows sistemlerinde kullanılabilir kültürler, ancak UNIX sistemlerinde başka kültürler de mevcuttur.In particular, "zh-CN", or Chinese (Simplified, China) and zh-TW, or Chinese (Traditional, Taiwan), are available cultures on Windows systems, but they are aliased cultures on Unix systems. "zh-CN", "zh-Hans-CN" kültürü için bir diğer addır ve "zh-TW", "zh-Hant-TW" kültürü için bir diğer addır."zh-CN" is an alias for the "zh-Hans-CN" culture, and "zh-TW" is an alias for the "zh-Hant-TW" culture. Diğer ad kültürler, GetCultures yöntemine yapılan çağrılar tarafından döndürülmez ve farklı Parent kültürleri de dahil olmak üzere Windows 'un karşılıklarından farklı özellik değerlerine sahip olabilir.Aliased cultures are not returned by calls to the GetCultures method and may have different property values, including different Parent cultures, than their Windows counterparts. Zh-CN ve zh-TW kültürleri için, bu farklılar şunları içerir:For the zh-CN and zh-TW cultures, these differenes include the following:

  • Windows sistemlerinde, "zh-CN" kültürünün üst kültürü "zh-Hans", "zh-TW" kültürünün üst kültürü "zh-Hant" dir.On Windows systems, the parent culture of the "zh-CN" culture is "zh-Hans", and the parent culture of the "zh-TW" culture is "zh-Hant". Her iki kültürün üst kültürü "zh" dir.The parent culture of both these cultures is "zh". UNIX sistemlerinde her iki kültürlerin üst öğeleri "zh" dir.On Unix systems, the parents of both cultures are "zh". Yani, "zh-CN" veya "zh-TW" kültürleri için kültüre özgü kaynaklar sağlamazsanız ancak nötr "zh-Hans" veya "zh-Hant" kültürü için bir kaynak sağlarsanız, uygulamanız Windows üzerinde bağımsız kültür için kaynakları yükler ancak UNIX 'e yüklemez .This means that, if you don't provide culture-specific resources for the "zh-CN" or "zh-TW" cultures but do provide a resources for the neutral "zh-Hans" or "zh-Hant" culture, your application will load the resources for the neutral culture on Windows but not on Unix. UNIX sistemlerinde, iş parçacığının CurrentUICulture ' ni "zh-Hans" veya "zh-Hant" olarak ayarlamanız gerekir.On Unix systems, you must explicitly set the thread's CurrentUICulture to either "zh-Hans" or "zh-Hant".

  • Windows sistemlerinde, "zh-CN" kültürünü temsil eden ve bir "zh-Hans-CN" örneği geçen bir örnekte CultureInfo.Equals çağırmak truedöndürür.On Windows systems, calling CultureInfo.Equals on an instance that represents the "zh-CN" culture and passing it a "zh-Hans-CN" instance returns true. UNIX sistemlerinde, yöntem çağrısı falsedöndürür.On Unix systems, the method call returns false. Bu davranış, bir "zh-TW" CultureInfo örneğindeki Equals çağırmak ve bir "zh-Hant-tw" örneği geçirmek için de geçerlidir.This behavior also applies to calling Equals on a "zh-TW" CultureInfo instance and passing it a "zh-Hant-Tw" instance.

Dinamik kültür verileriDynamic culture data

Sabit kültür haricinde kültür verileri dinamiktir.Except for the invariant culture, culture data is dynamic. Bu, önceden tanımlanmış kültürler için de geçerlidir.This is true even for the predefined cultures. Örneğin, ülkeler veya bölgeler yeni para birimlerini benimseyin, sözcüklerin yazım sayısını değiştirir veya tercih edilen takvimini değiştirir ve bunu izlemek için kültür tanımları değişir.For example, countries or regions adopt new currencies, change their spellings of words, or change their preferred calendar, and culture definitions change to track this. Özel kültürler bildirimde bulunulmadan değiştirilebilir ve belirli kültürler özel bir değiştirme kültürü tarafından geçersiz kılınabilir.Custom cultures are subject to change without notice, and any specific culture might be overridden by a custom replacement culture. Ayrıca, aşağıda anlatıldığı gibi, bireysel bir Kullanıcı kültürel tercihlerini geçersiz kılabilir.Also, as discussed below, an individual user can override cultural preferences. Uygulamalar her zaman çalışma zamanında kültür verileri almalıdır.Applications should always obtain culture data at run time.

Dikkat

Veriler kaydedilirken, uygulamanız sabit kültür, ikili biçim veya belirli bir kültür bağımsız biçimi kullanmalıdır.When saving data, your application should use the invariant culture, a binary format, or a specific culture-independent format. Sabit kültür dışında, belirli bir kültür ile ilişkili geçerli değerlere göre kaydedilen veriler okunamaz hale gelebilir veya söz konusu kültür değişirse anlam halinde değişebilir.Data saved according to the current values associated with a particular culture, other than the invariant culture, might become unreadable or might change in meaning if that culture changes.

Geçerli kültür ve geçerli UI kültürüThe current culture and current UI culture

Bir .NET uygulamasındaki her iş parçacığının geçerli bir kültürü ve geçerli bir UI kültürü vardır.Every thread in a .NET application has a current culture and a current UI culture. Geçerli kültür tarihler, saatler, rakamlar ve para birimi değerleri için biçimlendirme kurallarını, metnin sıralama düzenini, büyük/küçük harf kurallarını ve dizelerin karşılaştırılacağı yolları belirler.The current culture determines the formatting conventions for dates, times, numbers, and currency values, the sort order of text, casing conventions, and the ways in which strings are compared. Geçerli UI kültürü, çalışma zamanında kültüre özgü kaynakları almak için kullanılır.The current UI culture is used to retrieve culture-specific resources at runtime.

Not

Geçerli ve geçerli UI kültürünün iş parçacığı başına temelinde nasıl belirlendiği hakkında daha fazla bilgi için kültür ve iş parçacıkları bölümüne bakın.For information on how the current and current UI culture is determined on a per-thread basis, see the Culture and threads section. Geçerli ve geçerli UI kültürünün yeni bir uygulama etki alanında çalıştırılan iş parçacıklarında ve uygulama etki alanı sınırları üzerinde çalışan iş parçacıklarında nasıl belirlendiği hakkında bilgi edinmek için, kültür ve uygulama etki alanları bölümüne bakın.For information on how the current and current UI culture is determined on threads executing in a new application domain, and on threads that cross application domain boundaries, see the Culture and application domains section. Görev tabanlı zaman uyumsuz işlemler gerçekleştiren iş parçacıklarında geçerli ve geçerli 'nin nasıl belirlendiği hakkında bilgi için, bkz. kültür ve görev tabanlı zaman uyumsuz işlemler bölümü.For information on how the current and current is determined on threads performing task-based asynchronous operations, see the Culture and task-based asynchronous operations section.

Geçerli kültür hakkında daha ayrıntılı bilgi için CultureInfo.CurrentCulture özellik konusuna bakın.For more detailed information on the current culture, see the CultureInfo.CurrentCulture property topic. Geçerli UI kültürü hakkında daha ayrıntılı bilgi için CultureInfo.CurrentUICulture özellik konusuna bakın.For more detailed information on the current UI culture, see the CultureInfo.CurrentUICulture property topic.

Geçerli ve geçerli UI kültürlerini almaRetrieving the current and current UI cultures

Şu iki şekilde geçerli kültürü temsil eden bir CultureInfo nesnesi alabilirsiniz:You can get a CultureInfo object that represents the current culture in either of two ways:

Aşağıdaki örnek her iki özellik değerini alır, eşit oldukları ve geçerli kültürün adını gösterir.The following example retrieves both property values, compares them to show that they are equal, and displays the name of the current culture.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      CultureInfo culture1 = CultureInfo.CurrentCulture;
      CultureInfo culture2 = Thread.CurrentThread.CurrentCulture;
      Console.WriteLine("The current culture is {0}", culture1.Name);
      Console.WriteLine("The two CultureInfo objects are equal: {0}",
                        culture1 == culture2);
   }
}
// The example displays output like the following:
//     The current culture is en-US
//     The two CultureInfo objects are equal: True
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim culture1 As CultureInfo = CultureInfo.CurrentCulture
      Dim culture2 As CultureInfo = Thread.CurrentThread.CurrentCulture
      Console.WriteLine("The current culture is {0}", culture1.Name)
      Console.WriteLine("The two CultureInfo objects are equal: {0}",
                        culture1.Equals(culture2))
   End Sub
End Module
' The example displays output like the following:
'     The current culture is en-US
'     The two CultureInfo objects are equal: True

Geçerli Kullanıcı Arabirimi kültürünü iki şekilde temsil eden bir CultureInfo nesnesi alabilirsiniz:You can get a CultureInfo object that represents the current UI culture in either of two ways:

Aşağıdaki örnek her iki özellik değerini alır, eşit oldukları ve geçerli UI kültürünün adını gösterir.The following example retrieves both property values, compares them to show that they are equal, and displays the name of the current UI culture.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      CultureInfo uiCulture1 = CultureInfo.CurrentUICulture;
      CultureInfo uiCulture2 = Thread.CurrentThread.CurrentUICulture;
      Console.WriteLine("The current UI culture is {0}", uiCulture1.Name);
      Console.WriteLine("The two CultureInfo objects are equal: {0}",
                        uiCulture1 == uiCulture2);
   }
}
// The example displays output like the following:
//     The current UI culture is en-US
//     The two CultureInfo objects are equal: True
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim uiCulture1 As CultureInfo = CultureInfo.CurrentUICulture
      Dim uiCulture2 As CultureInfo = Thread.CurrentThread.CurrentUICulture
      Console.WriteLine("The current UI culture is {0}", uiCulture1.Name)
      Console.WriteLine("The two CultureInfo objects are equal: {0}",
                        uiCulture1.Equals(uiCulture2))
   End Sub
End Module
' The example displays output like the following:
'     The current UI culture is en-US
'     The two CultureInfo objects are equal: True

Geçerli ve geçerli UI kültürlerini ayarlamaSetting the current and current UI cultures

Bir iş parçacığının kültürünü ve Kullanıcı Arabirimi kültürünü değiştirmek için aşağıdakileri yapın:To change the culture and UI culture of a thread, do the following:

  1. Bir CultureInfo sınıf oluşturucusu çağırarak ve bunu kültür adı geçirerek kültürü temsil eden bir CultureInfo nesnesi örneği oluşturun.Instantiate a CultureInfo object that represents that culture by calling a CultureInfo class constructor and passing it the name of the culture. CultureInfo(String) Oluşturucusu, yeni kültür geçerli Windows kültürüyle aynıysa Kullanıcı geçersiz kılmalarını yansıtan bir CultureInfo nesnesi oluşturur.The CultureInfo(String) constructor instantiates a CultureInfo object that reflects user overrides if the new culture is the same as the current Windows culture. CultureInfo(String, Boolean) Oluşturucusu, yeni bir kültür geçerli Windows kültürüyle aynıysa, yeni örneklenmiş CultureInfo nesnesinin Kullanıcı geçersiz kılmalarını yansıtmasını belirtmenize olanak tanır.The CultureInfo(String, Boolean) constructor allows you to specify whether the newly instantiated CultureInfo object reflects user overrides if the new culture is the same as the current Windows culture.

  2. CultureInfo nesnesini .NET Core ve .NET Framework 4,6 ve sonraki sürümlerde CultureInfo.CurrentCulture veya CultureInfo.CurrentUICulture özelliğine atayın.Assign the CultureInfo object to the CultureInfo.CurrentCulture or CultureInfo.CurrentUICulture property on .NET Core and .NET Framework 4.6 and later versions. (.NET Framework 4.5.2 ve önceki sürümlerde, CultureInfo nesnesini Thread.CurrentCulture veya Thread.CurrentUICulture özelliğine atayabilirsiniz.)(On .NET Framework 4.5.2 and earlier versions, you can assign the CultureInfo object to the Thread.CurrentCulture or Thread.CurrentUICulture property.)

Aşağıdaki örnek geçerli kültürü alır.The following example retrieves the current culture. Fransızca (Fransa) kültürünün dışında herhangi bir şeydir, geçerli kültürü Fransızca (Fransa) olarak değiştirir.If it is anything other than the French (France) culture, it changes the current culture to French (France). Aksi takdirde, geçerli kültürü Fransızca (Lüksemburg) olarak değiştirir.Otherwise, it changes the current culture to French (Luxembourg).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo current = CultureInfo.CurrentCulture;
      Console.WriteLine("The current culture is {0}", current.Name);
      CultureInfo newCulture;
      if (current.Name.Equals("fr-FR"))
         newCulture = new CultureInfo("fr-LU");
      else   
         newCulture = new CultureInfo("fr-FR");
      
      CultureInfo.CurrentCulture = newCulture;
      Console.WriteLine("The current culture is now {0}", 
                        CultureInfo.CurrentCulture.Name);   
   }
}
// The example displays output like the following:
//     The current culture is en-US
//     The current culture is now fr-FR
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current As CultureInfo = CultureInfo.CurrentCulture
      Console.WriteLine("The current culture is {0}", current.Name)
      Dim newCulture As CultureInfo
      If current.Name.Equals("fr-FR") Then
         newCulture = New CultureInfo("fr-LU")
      Else   
         newCulture = new CultureInfo("fr-FR")
      End If
      
      CultureInfo.CurrentCulture = newCulture
      Console.WriteLine("The current culture is now {0}", 
                        CultureInfo.CurrentCulture.Name)   
   End Sub
End Module
' The example displays output like the following:
'     The current culture is en-US
'     The current culture is now fr-FR

Aşağıdaki örnek geçerli kültürü alır.The following example retrieves the current culture. Bu, Slovence (Slovenya) kültürüne başka bir şeydir, geçerli kültürü Slovence (Slovenya) olarak değiştirir.If it is anything other the Slovenian (Slovenia) culture, it changes the current culture to Slovenian (Slovenia). Aksi takdirde, geçerli kültürü Hırvatça (Hırvatistan) olarak değiştirir.Otherwise, it changes the current culture to Croatian (Croatia).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo current = CultureInfo.CurrentUICulture;
      Console.WriteLine("The current UI culture is {0}", current.Name);
      CultureInfo newUICulture;
      if (current.Name.Equals("sl-SI"))
         newUICulture = new CultureInfo("hr-HR");
      else   
         newUICulture = new CultureInfo("sl-SI");
      
      CultureInfo.CurrentUICulture = newUICulture;
      Console.WriteLine("The current UI culture is now {0}", 
                        CultureInfo.CurrentUICulture.Name);   
   }
}
// The example displays output like the following:
//     The current UI culture is en-US
//     The current UI culture is now sl-SI
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current As CultureInfo = CultureInfo.CurrentUICulture
      Console.WriteLine("The current UI culture is {0}", current.Name)
      Dim newUICulture As CultureInfo
      If current.Name.Equals("sl-SI") Then
         newUICulture = New CultureInfo("hr-HR")
      Else   
         newUICulture = new CultureInfo("sl-SI")
      End If
      
      CultureInfo.CurrentUICulture = newUICulture
      Console.WriteLine("The current UI culture is now {0}", 
                        CultureInfo.CurrentUICulture.Name)   
   End Sub
End Module
' The example displays output like the following:
'     The current UI culture is en-US
'     The current UI culture is now sl-SI

Tüm kültürleri almaGetting all cultures

GetCultures yöntemini çağırarak, yerel bilgisayarda bulunan belirli kültürlerin veya tüm kültürlerin dizisini alabilirsiniz.You can retrieve an array of specific categories of cultures or of all the cultures available on the local computer by calling the GetCultures method. Örneğin, özel kültürler, belirli kültürler veya nötr kültürleri tek başına ya da birlikte alabilirsiniz.For example, you can retrieve custom cultures, specific cultures, or neutral cultures either alone or in combination.

Aşağıdaki örnek, ilk olarak tüm özel kültürleri almak için System.Globalization.CultureTypes numaralandırma üyesiyle ve sonra tüm değiştirme kültürlerini almak için System.Globalization.CultureTypes sabit listesi üyesiyle birlikte GetCultures yöntemini iki kez çağırır.The following example calls the GetCultures method twice, first with the System.Globalization.CultureTypes enumeration member to retrieve all custom cultures, and then with the System.Globalization.CultureTypes enumeration member to retrieve all replacement cultures.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Get all custom cultures.
      CultureInfo[] custom = CultureInfo.GetCultures(CultureTypes.UserCustomCulture);
      if (custom.Length == 0) { 
         Console.WriteLine("There are no user-defined custom cultures.");
      }
      else {
         Console.WriteLine("Custom cultures:");
         foreach (var culture in custom) 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName);    
      }
      Console.WriteLine();
      
      // Get all replacement cultures.
      CultureInfo[] replacements = CultureInfo.GetCultures(CultureTypes.ReplacementCultures);
      if (replacements.Length == 0) { 
         Console.WriteLine("There are no replacement cultures.");
      }                                             
      else {
         Console.WriteLine("Replacement cultures:");
         foreach (var culture in replacements) 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName);    
      }
      Console.WriteLine();
   }
}
// The example displays output like the following:
//     Custom cultures:
//        x-en-US-sample -- English (United States)
//        fj-FJ -- Boumaa Fijian (Viti)
//     
//     There are no replacement cultures.
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Get all custom cultures.
      Dim custom() As CultureInfo = CultureInfo.GetCultures(CultureTypes.UserCustomCulture)
      If custom.Length = 0 Then 
         Console.WriteLine("There are no user-defined custom cultures.")
      Else
         Console.WriteLine("Custom cultures:")
         For Each culture In custom 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName)
         Next       
      End If
      Console.WriteLine()
      
      ' Get all replacement cultures.
      Dim replacements() As CultureInfo = CultureInfo.GetCultures(CultureTypes.ReplacementCultures)
      If replacements.Length = 0 Then 
         Console.WriteLine("There are no replacement cultures.")
      Else 
         Console.WriteLine("Replacement cultures:")
         For Each culture in replacements 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName)    
         Next
      End If
      Console.WriteLine()
   End Sub
End Module
' The example displays output like the following:
'     Custom cultures:
'        x-en-US-sample -- English (United States)
'        fj-FJ -- Boumaa Fijian (Viti)
'     
'     There are no replacement cultures.

Kültür ve iş parçacıklarıCulture and threads

Yeni bir uygulama iş parçacığı başlatıldığında, geçerli kültür ve geçerli kullanıcı arabirimi kültürü geçerli iş parçacığı kültürü tarafından değil geçerli sistem kültürü tarafından tanımlanır.When a new application thread is started, its current culture and current UI culture are defined by the current system culture, and not by the current thread culture. Aşağıdaki örnek, farkı göstermektedir.The following example illustrates the difference. Geçerli kültürü ve bir uygulama iş parçacığının geçerli kullanıcı Arabirimi kültürünü Fransızca (Fransa) kültürü (fr-FR) olarak ayarlar.It sets the current culture and current UI culture of an application thread to the French (France) culture (fr-FR). Geçerli kültür zaten fr-FR ise, örnek bunu Ingilizce (Birleşik Devletler) kültürüne (en-US) ayarlar.If the current culture is already fr-FR, the example sets it to the English (United States) culture (en-US). Üç rastgele sayıyı para birimi değeri olarak görüntüler ve ardından yeni bir iş parçacığı oluşturur. Bu, sırasıyla para birimi değeri olarak üç rastgele sayıyı görüntüler.It displays three random numbers as currency values and then creates a new thread, which, in turn, displays three more random numbers as currency values. Ancak örnekteki Çıktının gösterdiği gibi, yeni iş parçacığı tarafından gösterilen para birimi değerleri, ana uygulama iş parçacığından gelen çıkışın aksine Fransızca (Fransa) kültürünün biçimlendirme kurallarını yansıtmaz.But as the output from the example shows, the currency values displayed by the new thread do not reflect the formatting conventions of the French (France) culture, unlike the output from the main application thread.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   static Random rnd = new Random();
   
   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }
      else {
         // Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      ThreadProc();
          
      Thread worker = new Thread(ThreadProc);
      worker.Name = "WorkerThread";
      worker.Start();
   }
   
   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'", 
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);                        
   }
   
   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);                        
   }
   
   private static void ThreadProc()
   {
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          8,11 €
//          1,48 €
//          8,99 €
//          9,04 €
//       
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: en-US/en-US
//       Some currency values:
//          $6.72
//          $6.35
//          $2.90
//          $7.72
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR")
      Else
         ' Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US")
      End If
      ThreadProc()
          
       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start()
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc()
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' The example displays output similar to the following:
'       Current Thread Name: ''
'       Current Thread Culture/UI Culture: fr-FR/fr-FR
'       Some currency values:
'          8,11 €
'          1,48 €
'          8,99 €
'          9,04 €
'       
'       Current Thread Name: 'WorkerThread'
'       Current Thread Culture/UI Culture: en-US/en-US
'       Some currency values:
'          $6.72
'          $6.35
'          $2.90
'          $7.72

.NET Framework 4.5.NET Framework 4.5önceki .NET Framework sürümlerinde, ana uygulama iş parçacığının diğer tüm çalışan iş parçacıklarıyla aynı kültürü paylaştığı sağlamanın en yaygın yolu, uygulama genelinde kültürün adını veya uygulama genelinde kültürü temsil eden bir CultureInfo nesnesini bir System.Threading.ParameterizedThreadStart temsilcisine geçirmektir.In versions of the .NET Framework before the .NET Framework 4.5.NET Framework 4.5, the most common way to ensure that the main application thread shares the same culture with all other worker threads is to pass either the name of the application-wide culture or a CultureInfo object that represents the application-wide culture to a System.Threading.ParameterizedThreadStart delegate. Aşağıdaki örnek, iki iş parçacığı tarafından görüntülenen para birimi değerlerinin aynı kültürün biçimlendirme kurallarını yansıttığından emin olmak için bu yaklaşımı kullanır.The following example uses this approach to ensure that the currency values displayed by two threads reflect the formatting conventions of the same culture.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   static Random rnd = new Random();
   
   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }   
      else {
         // Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      DisplayThreadInfo();
      DisplayValues();
          
       Thread worker = new Thread(Example.ThreadProc);
       worker.Name = "WorkerThread";
       worker.Start(Thread.CurrentThread.CurrentCulture);
   }
   
   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'", 
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);                        
   }
   
   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);                        
   }
   
   private static void ThreadProc(Object obj) 
   {
      Thread.CurrentThread.CurrentCulture = (CultureInfo) obj;
      Thread.CurrentThread.CurrentUICulture = (CultureInfo) obj;
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          6,83 €
//          3,47 €
//          6,07 €
//          1,70 €
//       
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          9,54 €
//          9,50 €
//          0,58 €
//          6,91 €
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR")
      Else
         ' Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US")
      End If
      DisplayThreadInfo()
      DisplayValues()
          
       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start(Thread.CurrentThread.CurrentCulture)
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc(obj As Object)
      Thread.CurrentThread.CurrentCulture = CType(obj, CultureInfo)
      Thread.CurrentThread.CurrentUICulture = CType(obj, CultureInfo)
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' The example displays output similar to the following:
'       Current Thread Name: ''
'       Current Thread Culture/UI Culture: fr-FR/fr-FR
'       Some currency values:
'          6,83 €
'          3,47 €
'          6,07 €
'          1,70 €
'       
'       Current Thread Name: 'WorkerThread'
'       Current Thread Culture/UI Culture: fr-FR/fr-FR
'       Some currency values:
'          9,54 €
'          9,50 €
'          0,58 €
'          6,91 €

ThreadPool.QueueUserWorkItem(WaitCallback, Object) yöntemini çağırarak, iş parçacığı havuzu iş parçacıklarının kültür ve Kullanıcı Arabirimi kültürünü benzer bir şekilde ayarlayabilirsiniz.You can set the culture and UI culture of thread pool threads in a similar manner by calling the ThreadPool.QueueUserWorkItem(WaitCallback, Object) method.

.NET Framework 4.5.NET Framework 4.5başlayarak, bir uygulama etki alanındaki tüm iş parçacıklarının kültür ve Kullanıcı Arabirimi kültürünü, DefaultThreadCurrentCulture ve DefaultThreadCurrentUICulture özelliklerine ilişkin kültürü temsil eden bir CultureInfo nesnesi atayarak doğrudan ayarlayabilirsiniz.Starting with the .NET Framework 4.5.NET Framework 4.5, you can set the culture and UI culture of all threads in an application domain more directly by assigning a CultureInfo object that represents that culture to the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties. Aşağıdaki örnek, varsayılan uygulama etki alanındaki tüm iş parçacıklarının aynı kültürü paylaştığından emin olmak için bu özellikleri kullanır.The following example uses these properties to ensure that all threads in the default application domain share the same culture.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   static Random rnd = new Random();
   
   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }   
      else {
         // Set culture to en-US.
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      ThreadProc();
          
      Thread worker = new Thread(Example.ThreadProc);
      worker.Name = "WorkerThread";
      worker.Start();
   }
   
   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'", 
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);                        
   }
   
   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);                        
   }
   
   private static void ThreadProc() 
   {
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          6,83 €
//          3,47 €
//          6,07 €
//          1,70 €
//       
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          9,54 €
//          9,50 €
//          0,58 €
//          6,91 €
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' If current culture is not fr-FR, set culture to fr-FR.
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR")
      Else
         ' Set culture to en-US.
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("en-US")
      End If
      ThreadProc()

       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start()
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc()
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' The example displays output similar to the following:
'       Current Thread Name: ''
'       Current Thread Culture/UI Culture: fr-FR/fr-FR
'       Some currency values:
'          6,83 €
'          3,47 €
'          6,07 €
'          1,70 €
'       
'       Current Thread Name: 'WorkerThread'
'       Current Thread Culture/UI Culture: fr-FR/fr-FR
'       Some currency values:
'          9,54 €
'          9,50 €
'          0,58 €
'          6,91 €

Uyarı

DefaultThreadCurrentCulture ve DefaultThreadCurrentUICulture özellikleri statik üyeler olsa da, varsayılan kültür ve varsayılan UI kültürünü yalnızca bu özellik değerleri ayarlandığı sırada geçerli olan uygulama etki alanı için tanımlar.Although the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties are static members, they define the default culture and default UI culture only for the application domain that is current at the time these property values are set. Daha fazla bilgi için bkz. bir sonraki bölüm, kültür ve uygulama etki alanları.For more information, see the next section, Culture and application domains.

DefaultThreadCurrentCulture ve DefaultThreadCurrentUICulture özelliklerine değer atadığınızda, uygulama etki alanındaki iş parçacıklarının kültür ve UI kültürü, açıkça bir kültür atanmadıklarında de değişir.When you assign values to the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties, the culture and UI culture of the threads in the application domain also change if they have not explicitly been assigned a culture. Ancak, bu iş parçacıkları yeni kültür ayarlarını yalnızca geçerli uygulama etki alanında yürütüken yansıtır.However, these threads reflect the new culture settings only while they execute in the current application domain. Bu iş parçacıkları başka bir uygulama etki alanında yürütüolduysa, kültürü bu uygulama etki alanı için tanımlanan varsayılan kültür haline gelir.If these threads execute in another application domain, their culture becomes the default culture defined for that application domain. Sonuç olarak, bir ana uygulama iş parçacığının kültürünü her zaman ayarlamanızı ve DefaultThreadCurrentCulture ve DefaultThreadCurrentUICulture özelliklerini değiştirmeniz önerilir.As a result, we recommend that you always set the culture of the main application thread, and not rely on the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties to change it.

Kültür ve uygulama etki alanlarıCulture and application domains

DefaultThreadCurrentCulture ve DefaultThreadCurrentUICulture, yalnızca özellik değeri ayarlandığında veya alındığında geçerli olan uygulama etki alanı için varsayılan kültürü açıkça tanımlayan statik özelliklerdir.DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture are static properties that explicitly define a default culture only for the application domain that is current when the property value is set or retrieved. Aşağıdaki örnek varsayılan kültür ve varsayılan kullanıcı Arabirimi kültürünü varsayılan uygulama etki alanında Fransızca (Fransa) olarak ayarlar ve ardından yeni bir uygulama etki alanında varsayılan kültürü ve Kullanıcı Arabirimi kültürünü Rusça (Rusya) olarak ayarlamak için AppDomainSetup sınıfını ve AppDomainInitializer temsilcisini kullanır.The following example sets the default culture and default UI culture in the default application domain to French (France), and then uses the AppDomainSetup class and the AppDomainInitializer delegate to set the default culture and UI culture in a new application domain to Russian (Russia). Tek bir iş parçacığı, her uygulama etki alanında iki yöntemi yürütür.A single thread then executes two methods in each application domain. İş parçacığının kültür ve UI kültürünün açıkça ayarlanmamış olduğunu unutmayın; Bunlar, iş parçacığının yürütüldüğü uygulama etki alanının varsayılan kültür ve Kullanıcı arabirimi kültüründen türetilir.Note that the thread's culture and UI culture are not explicitly set; they are derived from the default culture and UI culture of the application domain in which the thread is executing. Ayrıca DefaultThreadCurrentCulture ve DefaultThreadCurrentUICulture özelliklerinin, yöntem çağrısı yapıldığında geçerli olan uygulama etki alanının varsayılan CultureInfo değerlerini döndürdüğüne de unutmayın.Note also that the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties return the default CultureInfo values of the application domain that is current when the method call is made.

using System;
using System.Globalization;
using System.Reflection;
using System.Threading;

public class Example
{
   public static void Main()
   {
      // Set the default culture and display the current date in the current application domain.
      Info info1 = new Info();
      SetAppDomainCultures("fr-FR");
      
      // Create a second application domain.
      AppDomainSetup setup = new AppDomainSetup();
      setup.AppDomainInitializer = SetAppDomainCultures;
      setup.AppDomainInitializerArguments = new string[] { "ru-RU" };
      AppDomain domain = AppDomain.CreateDomain("Domain2", null, setup);
      // Create an Info object in the new application domain.
      Info info2 = (Info) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName, 
                                                         "Info"); 

      // Execute methods in the two application domains.
      info2.DisplayDate();
      info2.DisplayCultures();
      
      info1.DisplayDate();
      info1.DisplayCultures();            
   }

   public static void SetAppDomainCultures(string[] names)
   {
      SetAppDomainCultures(names[0]);
   }
   
   public static void SetAppDomainCultures(string name)
   {
       try {
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name);
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name);
      }
      // If an exception occurs, we'll just fall back to the system default.
      catch (CultureNotFoundException) {
         return;
      }   
      catch (ArgumentException) {
         return;
      } 
   }
}

public class Info : MarshalByRefObject
{
   public void DisplayDate()
   {
      Console.WriteLine("Today is {0:D}", DateTime.Now);
   }
   
   public void DisplayCultures()
   {
      Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id);
      Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture);
      Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture);
   }
}
// The example displays the following output:
//       Today is 14 октября 2011 г.
//       Application domain is 2
//       Default Culture: ru-RU
//       Default UI Culture: ru-RU
//       Today is vendredi 14 octobre 2011
//       Application domain is 1
//       Default Culture: fr-FR
//       Default UI Culture: fr-FR
Imports System.Globalization
Imports System.Reflection
Imports System.Threading

Module Example
   Public Sub Main()
      ' Set the default culture and display the current date in the current application domain.
      Dim info1 As New Info()
      SetAppDomainCultures("fr-FR")
      
      ' Create a second application domain.
      Dim setup As New AppDomainSetup()
      setup.AppDomainInitializer = AddressOf SetAppDomainCultures
      setup.AppDomainInitializerArguments = { "ru-RU" }
      Dim domain As AppDomain = AppDomain.CreateDomain("Domain2", Nothing, setup)
      ' Create an Info object in the new application domain.
      Dim info2 As Info = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName, 
                                                               "Info"), Info) 

      ' Execute methods in the two application domains.
      info2.DisplayDate()
      info2.DisplayCultures()
      
      info1.DisplayDate()
      info1.DisplayCultures()            
   End Sub
   
   Public Sub SetAppDomainCultures(names() As String)
      SetAppDomainCultures(names(0))
   End Sub
   
   Public Sub SetAppDomainCultures(name As String)
       Try
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name)
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name)
      ' If an exception occurs, we'll just fall back to the system default.
      Catch e As CultureNotFoundException
         Return
      Catch e As ArgumentException
         Return
      End Try      
   End Sub
End Module

Public Class Info : Inherits MarshalByRefObject
   Public Sub DisplayDate()
      Console.WriteLine("Today is {0:D}", Date.Now)
   End Sub
   
   Public Sub DisplayCultures()
      Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id)
      Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture)
      Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture)
   End Sub
End Class
' The example displays the following output:
'       Today is 14 октября 2011 г.
'       Application domain is 2
'       Default Culture: ru-RU
'       Default UI Culture: ru-RU
'       Today is vendredi 14 octobre 2011
'       Application domain is 1
'       Default Culture: fr-FR
'       Default UI Culture: fr-FR

Kültürler ve uygulama etki alanları hakkında daha fazla bilgi için uygulama etki alanları konusunun "uygulama etki alanları ve iş parçacıkları" bölümüne bakın.For more information about cultures and application domains, see the "Application Domains and Threads" section in the Application Domains topic.

Kültür ve görev tabanlı zaman uyumsuz işlemlerCulture and task-based asynchronous operations

Görev tabanlı zaman uyumsuz programlama stili , iş parçacığı havuzu iş parçacıklarında temsilcileri zaman uyumsuz olarak yürütmek için Task ve Task<TResult> nesnelerini kullanır.The task-based asynchronous programming pattern uses Task and Task<TResult> objects to asynchronously execute delegates on thread pool threads. Belirli bir görevin çalıştırıldığı belirli iş parçacığı önceden bilinmiyor, ancak yalnızca çalışma zamanında belirlenir.The specific thread on which a particular task runs is not known in advance, but is determined only at runtime.

.NET Framework 4.6.NET Framework 4.6 veya sonraki sürümlerini hedefleyen uygulamalar için kültür, zaman uyumsuz bir işlemin bağlamının bir parçasıdır.For apps that target the .NET Framework 4.6.NET Framework 4.6 or later versions, culture is part of an asynchronous operation's context. Diğer bir deyişle, .NET Framework 4.6.NET Framework 4.6hedefleyen uygulamalardan başlayarak, varsayılan olarak zaman uyumsuz işlemler, CurrentCulture değerlerini ve başlatıldığı iş parçacığının CurrentUICulture özelliklerini alırlar.In other words, starting with apps that target the .NET Framework 4.6.NET Framework 4.6, asynchronous operations by default inherit the values of the CurrentCulture and CurrentUICulture properties of the thread from which they are launched. Geçerli kültür veya geçerli kullanıcı arabirimi kültürü sistem kültüründen farklıysa, geçerli kültür iş parçacığı sınırlarını keser ve zaman uyumsuz bir işlem yürüten iş parçacığı havuzu iş parçacığının geçerli kültürü olur.If the current culture or current UI culture differs from the system culture, the current culture crosses thread boundaries and becomes the current culture of the thread pool thread that is executing an asynchronous operation.

Aşağıdaki örnek basit bir çizim sağlar.The following example provides a simple illustration. .NET Framework 4.6.NET Framework 4.6hedeflemek için TargetFrameworkAttribute özniteliğini kullanır.It uses the TargetFrameworkAttribute attribute to target the .NET Framework 4.6.NET Framework 4.6. Örnek, para birimi değeri olarak biçimlendirilen bazı sayılar döndüren formatDelegateFunc<TResult> temsilcisini tanımlar.The example defines a Func<TResult> delegate, formatDelegate, that returns some numbers formatted as currency values. Örnek, geçerli sistem kültürünü Fransızca (Fransa) ya da Fransızca (Fransa) zaten geçerli kültür (Ingilizce) (Birleşik Devletler) olarak değiştirir.The example changes the current system culture to either French (France) or, if French (France) is already the current culture, English (United States). Daha sonra:It then:

  • Temsilciyi, ana uygulama iş parçacığında eşzamanlı olarak çalışacak şekilde doğrudan çağırır.Invokes the delegate directly so that it runs synchronously on the main app thread.

  • İş parçacığı havuzu iş parçacığında temsilciyi zaman uyumsuz olarak yürüten bir görev oluşturur.Creates a task that executes the delegate asynchronously on a thread pool thread.

  • Task.RunSynchronously yöntemini çağırarak, ana uygulama iş parçacığında temsilciyi eşzamanlı olarak yürüten bir görev oluşturur.Creates a task that executes the delegate synchronously on the main app thread by calling the Task.RunSynchronously method.

Örnekteki Çıktının gösterdiği gibi, geçerli kültür Fransızca (Fransa) olarak değiştirildiğinde, görevlerin zaman uyumsuz olarak çağrıldığı iş parçacığının geçerli kültürü, o zaman uyumsuz işlem için geçerli kültür olur.As the output from the example shows, when the current culture is changed to French (France), the current culture of the thread from which tasks are invoked asynchronously becomes the current culture for that asynchronous operation.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

[assembly:TargetFramework(".NETFramework,Version=v4.6")]

public class Example
{
   
   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));
                                                   
                                             output += Environment.NewLine;
                                             return output;
                                           };
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);
       
       // Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:");
       Console.WriteLine(formatDelegate());
       
       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:"); 
       var t1 = Task.Run(formatDelegate);
       Console.WriteLine(t1.Result);
       
       Console.WriteLine("Executing a task synchronously:");
       var t2 = new Task<String>(formatDelegate); 
       t2.RunSynchronously();
       Console.WriteLine(t2.Result);
   }
}
// The example displays the following output:
//         The example is running on thread 1
//         The current culture is en-US
//         Changed the current culture to fr-FR.
//
//         Executing the delegate synchronously:
//         Formatting using the fr-FR culture on thread 1.
//         163 025 412,32 €   18 905 365,59 €
//
//         Executing a task asynchronously:
//         Formatting using the fr-FR culture on thread 3.
//         163 025 412,32 €   18 905 365,59 €
//
//         Executing a task synchronously:
//         Formatting using the fr-FR culture on thread 1.
//         163 025 412,32 €   18 905 365,59 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

<Assembly:TargetFramework(".NETFramework,Version=v4.6")>

Module Example
   Public Sub Main()
       Dim values() As Decimal = { 163025412.32d, 18905365.59d }
       Dim formatString As String = "C2"
       Dim formatDelegate As Func(Of String) = Function()
                                                  Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                       CultureInfo.CurrentCulture.Name,
                                                                                       Thread.CurrentThread.ManagedThreadId)
                                                  output += Environment.NewLine
                                                  For Each value In values
                                                     output += String.Format("{0}   ", value.ToString(formatString))
                                                  Next 
                                                  output += Environment.NewLine
                                                  Return output
                                               End Function
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId)
       ' Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name)
       If CultureInfo.CurrentCulture.Name = "fr-FR" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If
       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()                  
       
       ' Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:")
       Console.WriteLine(formatDelegate())
       
       ' Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:") 
       Dim t1 = Task.Run(formatDelegate)
       Console.WriteLine(t1.Result)
       
       Console.WriteLine("Executing a task synchronously:")
       Dim t2 = New Task(Of String)(formatDelegate) 
       t2.RunSynchronously()
       Console.WriteLine(t2.Result)
   End Sub
End Module
' The example displays the following output:
'          The example is running on thread 1
'          The current culture is en-US
'          Changed the current culture to fr-FR.
'
'          Executing the delegate synchronously:
'          Formatting Imports the fr-FR culture on thread 1.
'          163 025 412,32 €   18 905 365,59 €
'
'          Executing a task asynchronously:
'          Formatting Imports the fr-FR culture on thread 3.
'          163 025 412,32 €   18 905 365,59 €
'
'          Executing a task synchronously:
'          Formatting Imports the fr-FR culture on thread 1.
'          163 025 412,32 €   18 905 365,59 €

.NET Framework 4.6.NET Framework 4.6veya .NET Framework belirli bir sürümünü Hedeflemeyin .NET Framework sürümlerini hedefleyen uygulamalar için, çağıran iş parçacığının kültürü bir görevin bağlamına ait değildir.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6.NET Framework 4.6, or for apps that do not target a particular version of the .NET Framework, the culture of the calling thread is not part of a task's context. Bunun yerine, bir tane açıkça tanımlanmadığı müddetçe, varsayılan olarak yeni iş parçacıklarının kültürü sistem kültürüdür.Instead, unless one is explicitly defined, the culture of new threads by default is the system culture. Aşağıdaki örnek, TargetFrameworkAttribute özniteliğinin eksik olması dışında, önceki örnekle aynıdır, bunu gösterir.The following example, which is identical to the previous example except that it lacks the TargetFrameworkAttribute attribute, illustrates this. Örneğin yürütüldüğü sistemin sistem kültürü Ingilizce (Birleşik Devletler) olduğundan, iş parçacığı havuzu iş parçacığında zaman uyumsuz olarak yürütülen görevin kültürü fr-FR yerine en-US ' dir.Because the system culture of the system on which the example executed was English (United States), the culture of the task that executes asynchronously on a thread pool thread is en-US rather than fr-FR.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));
                                                   
                                             output += Environment.NewLine;
                                             return output;
                                           };
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);
       
       // Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:");
       Console.WriteLine(formatDelegate());
       
       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:"); 
       var t1 = Task.Run(formatDelegate);
       Console.WriteLine(t1.Result);
       
       Console.WriteLine("Executing a task synchronously:");
       var t2 = new Task<String>(formatDelegate); 
       t2.RunSynchronously();
       Console.WriteLine(t2.Result);
   }
}
// The example displays the following output:
//     The example is running on thread 1
//     The current culture is en-US
//     Changed the current culture to fr-FR.
//     
//     Executing the delegate synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163 025 412,32 €   18 905 365,59 €
//     
//     Executing a task asynchronously:
//     Formatting using the en-US culture on thread 3.
//     $163,025,412.32   $18,905,365.59
//     
//     Executing a task synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163 025 412,32 €   18 905 365,59 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
       Dim values() As Decimal = { 163025412.32d, 18905365.59d }
       Dim formatString As String = "C2"
       Dim formatDelegate As Func(Of String) = Function()
                                                  Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                       CultureInfo.CurrentCulture.Name,
                                                                                       Thread.CurrentThread.ManagedThreadId)
                                                  output += Environment.NewLine
                                                  For Each value In values
                                                     output += String.Format("{0}   ", value.ToString(formatString))
                                                  Next 
                                                  output += Environment.NewLine
                                                  Return output
                                               End Function
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId)
       ' Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name)
       If CultureInfo.CurrentCulture.Name = "fr-FR" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If
       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()                  
       
       ' Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:")
       Console.WriteLine(formatDelegate())
       
       ' Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:") 
       Dim t1 = Task.Run(formatDelegate)
       Console.WriteLine(t1.Result)
       
       Console.WriteLine("Executing a task synchronously:")
       Dim t2 = New Task(Of String)(formatDelegate) 
       t2.RunSynchronously()
       Console.WriteLine(t2.Result)
   End Sub
End Module
' The example displays the following output:
'     The example is running on thread 1
'     The current culture is en-US
'     Changed the current culture to fr-FR.
'     
'     Executing the delegate synchronously:
'     Formatting using the fr-FR culture on thread 1.
'     163 025 412,32 €   18 905 365,59 €
'     
'     Executing a task asynchronously:
'     Formatting using the en-US culture on thread 3.
'     $163,025,412.32   $18,905,365.59
'     
'     Executing a task synchronously:
'     Formatting using the fr-FR culture on thread 1.
'     163 025 412,32 €   18 905 365,59 €

.NET Framework 4.5.NET Framework 4.5 ve sonrasında .NET Framework sürümlerini hedefleyen uygulamalar için, .NET Framework 4.6.NET Framework 4.6önce, çağıran iş parçacığının kültürünün iş parçacığı havuzu iş parçacıklarında yürütülen zaman uyumsuz görevlerde kullanıldığından emin olmak için DefaultThreadCurrentCulture ve DefaultThreadCurrentUICulture özelliklerini kullanabilirsiniz.For apps that target versions of the .NET Framework from the .NET Framework 4.5.NET Framework 4.5 and later but prior to the .NET Framework 4.6.NET Framework 4.6, you can use the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties to ensure that the culture of the calling thread is used in asynchronous tasks that execute on thread pool threads. Aşağıdaki örnek, bir önceki örnekle aynıdır, ancak iş parçacığı havuzu iş parçacıklarının ana uygulama iş parçacığıyla aynı kültüre sahip olduğundan emin olmak için DefaultThreadCurrentCulture özelliğini kullanır.The following example is identical to the previous example, except that it uses the DefaultThreadCurrentCulture property to ensure that thread pool threads have the same culture as the main app thread.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));
                                                   
                                             output += Environment.NewLine;
                                             return output;
                                           };
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);
       CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CurrentCulture;
       
       // Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:");
       Console.WriteLine(formatDelegate());
       
       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:"); 
       var t1 = Task.Run(formatDelegate);
       Console.WriteLine(t1.Result);
       
       Console.WriteLine("Executing a task synchronously:");
       var t2 = new Task<String>(formatDelegate); 
       t2.RunSynchronously();
       Console.WriteLine(t2.Result);
   }
}
// The example displays the following output:
//     The example is running on thread 1
//     The current culture is en-US
//     Changed the current culture to fr-FR.
//     
//     Executing the delegate synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163 025 412,32 €   18 905 365,59 €
//     
//     Executing a task asynchronously:
//     Formatting using the fr-FR culture on thread 3.
//     163 025 412,32 €   18 905 365,59 €
//     
//     Executing a task synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163 025 412,32 €   18 905 365,59 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
       Dim values() As Decimal = { 163025412.32d, 18905365.59d }
       Dim formatString As String = "C2"
       Dim formatDelegate As Func(Of String) = Function()
                                                  Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                       CultureInfo.CurrentCulture.Name,
                                                                                       Thread.CurrentThread.ManagedThreadId)
                                                  output += Environment.NewLine
                                                  For Each value In values
                                                     output += String.Format("{0}   ", value.ToString(formatString))
                                                  Next 
                                                  output += Environment.NewLine
                                                  Return output
                                               End Function
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId)
       ' Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name)
       If CultureInfo.CurrentCulture.Name = "fr-FR" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If
       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CurrentCulture
       Console.WriteLine()                  
       
       ' Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:")
       Console.WriteLine(formatDelegate())
       
       ' Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:") 
       Dim t1 = Task.Run(formatDelegate)
       Console.WriteLine(t1.Result)
       
       Console.WriteLine("Executing a task synchronously:")
       Dim t2 = New Task(Of String)(formatDelegate) 
       t2.RunSynchronously()
       Console.WriteLine(t2.Result)
   End Sub
End Module
' The example displays the following output:
'       The example is running on thread 1
'       The current culture is en-US
'       Changed the current culture to fr-FR.
'       
'       Executing the delegate synchronously:
'       Formatting using the fr-FR culture on thread 1.
'       163 025 412,32 €   18 905 365,59 €
'       
'       Executing a task asynchronously:
'       Formatting using the fr-FR culture on thread 3.
'       163 025 412,32 €   18 905 365,59 €
'       
'       Executing a task synchronously:
'       Formatting using the fr-FR culture on thread 1.
'       163 025 412,32 €   18 905 365,59 €

DefaultThreadCurrentCulture ve DefaultThreadCurrentUICulture uygulama başına etki alanı özellikleridir; diğer bir deyişle, belirli bir uygulama etki alanında açıkça bir kültür atanmamış tüm iş parçacıkları için varsayılan bir kültür oluştururlar.DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture are per-app domain properties; that is, they establish a default culture for all threads not explicitly assigned a culture in a specific application domain. Ancak, .NET Framework 4.6.NET Framework 4.6 veya üstünü hedefleyen uygulamalar için çağıran iş parçacığının kültürü, görev uygulama etki alanı sınırlarını aşsa bile, zaman uyumsuz bir görevin içeriğinin bir parçası olarak kalır.However, for apps that target the .NET Framework 4.6.NET Framework 4.6 or later, the culture of the calling thread remains part of an asynchronous task's context even if the task crosses app domain boundaries.

Aşağıdaki örnek, görevin yürütüldüğü Yöntem uygulama etki alanı sınırlarını aşsa bile, çağıran iş parçacığının kültürünün, görev tabanlı zaman uyumsuz işlemin geçerli kültürünü kaldığını gösterir.The following example shows that the calling thread's culture remains the current culture of a task-based asynchronous operation even if the method that the task is executing crosses application domain boundaries. 1 ile 1.000 arasında bir para birimi değeri olarak biçimlendirilen rastgele bir çift duyarlıklı kayan noktalı sayı döndüren tek bir yöntem olan GetFormattedNumber``DataRetrieverbir sınıfı tanımlar.It defines a class, DataRetriever, with a single method, GetFormattedNumber, that returns a random double-precision floating-point number between 1 and 1,000 formatted as a currency value. Yalnızca bir DataRetriever örneği örnekleyen ve GetFormattedNumber yöntemini çağıran ilk görev çalıştırılır.A first task is run that simply instantiates a DataRetriever instance and calls its GetFormattedNumber method. İkinci bir görev, geçerli uygulama etki alanını bildirir, yeni bir uygulama etki alanı oluşturur, yeni uygulama etki alanında bir DataRetriever örneğini başlatır ve GetFormattedNumber yöntemini çağırır.A second task reports its current application domain, creates a new application domain, instantiates a DataRetriever instance in the new application domain, and calls its GetFormattedNumber method. Örnekteki Çıktının gösterdiği gibi, geçerli kültür çağıran iş parçacığında, ilk görevde ve ikinci görevde her ikisi de ana uygulama etki alanında ve ikinci uygulama etki alanında yürütüldüğü zaman aynı şekilde kaldığı yerden aynı şekilde kaldığını gösterir.As the output from the example shows, the current culture has remained the same in the calling thread, the first task, and the second task both when it was executing in the main application domain and the second application domain.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

[assembly:TargetFramework(".NETFramework,Version=v4.6")]

public class Example
{
   public static void Main()
   {
       string formatString = "C2";
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);
       
       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously in the main appdomain:"); 
       var t1 = Task.Run(() => { DataRetriever d = new DataRetriever();
                                 return d.GetFormattedNumber(formatString);
                               });
       Console.WriteLine(t1.Result);
       Console.WriteLine(); 
       
       Console.WriteLine("Executing a task synchronously in two appdomains:");
       var t2 = Task.Run(() => { Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                                                   Thread.CurrentThread.ManagedThreadId, 
                                                   AppDomain.CurrentDomain.FriendlyName);
                                 AppDomain domain = AppDomain.CreateDomain("Domain2");
                                 DataRetriever d = (DataRetriever) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName,
                                                   "DataRetriever");
                                 return d.GetFormattedNumber(formatString); 
                               }); 
       Console.WriteLine(t2.Result);
   }
}

public class DataRetriever : MarshalByRefObject
{
   public string GetFormattedNumber(String format)
   {
      Thread thread = Thread.CurrentThread;
      Console.WriteLine("Current culture is {0}", thread.CurrentCulture);
      Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                        thread.ManagedThreadId, 
                        AppDomain.CurrentDomain.FriendlyName);
      Random rnd = new Random();
      Double value = rnd.NextDouble() * 1000;
      return value.ToString(format);
   }
}
// The example displays output like the following:
//     The example is running on thread 1
//     The current culture is en-US
//     Changed the current culture to fr-FR.
//     
//     Executing a task asynchronously in a single appdomain:
//     Current culture is fr-FR
//     Thread 3 is running in app domain 'AsyncCulture4.exe'
//     93,48 €
//     
//     Executing a task synchronously in two appdomains:
//     Thread 4 is running in app domain 'AsyncCulture4.exe'
//     Current culture is fr-FR
//     Thread 4 is running in app domain 'Domain2'
//     288,66 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

<Assembly:TargetFramework(".NETFramework,Version=v4.6")>

Module Example
   Public Sub Main()
       Dim formatString As String = "C2"
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId)
       ' Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name)
       If CultureInfo.CurrentCulture.Name = "fr-FR" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If

       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()
       
       ' Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously in the main appdomain:") 
       Dim t1 = Task.Run(Function()
                            Dim d As New DataRetriever()
                            Return d.GetFormattedNumber(formatString)
                         End Function)
       Console.WriteLine(t1.Result)
       Console.WriteLine() 
       
       Console.WriteLine("Executing a task synchronously in two appdomains:")
       Dim t2 = Task.Run(Function()
                            Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                                              Thread.CurrentThread.ManagedThreadId, 
                                              AppDomain.CurrentDomain.FriendlyName)
                            Dim domain As AppDomain = AppDomain.CreateDomain("Domain2")
                            Dim d As DataRetriever = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName,
                                                                                          "DataRetriever"), DataRetriever)
                            Return d.GetFormattedNumber(formatString) 
                         End Function) 
       Console.WriteLine(t2.Result)
   End Sub
End Module

Public Class DataRetriever : Inherits MarshalByRefObject
   Public Function GetFormattedNumber(format As String) As String
      Dim thread As Thread = Thread.CurrentThread
      Console.WriteLine("Current culture is {0}", thread.CurrentCulture)
      Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                        thread.ManagedThreadId, 
                        AppDomain.CurrentDomain.FriendlyName)
      Dim rnd As New Random()
      Dim value As Double = rnd.NextDouble() * 1000
      Return value.ToString(format)
   End Function
End Class
' The example displays output like the following:
'     The example is running on thread 1
'     The current culture is en-US
'     Changed the current culture to fr-FR.
'     
'     Executing a task asynchronously in a single appdomain:
'     Current culture is fr-FR
'     Thread 3 is running in app domain 'AsyncCulture4.exe'
'     93,48 €
'     
'     Executing a task synchronously in two appdomains:
'     Thread 4 is running in app domain 'AsyncCulture4.exe'
'     Current culture is fr-FR
'     Thread 4 is running in app domain 'Domain2'
'     288,66 €

CultureInfo nesne serileştirmeCultureInfo object serialization

CultureInfo bir nesne serileştirildiğinde, gerçekte depolanan tümü Name ve UseUserOverride.When a CultureInfo object is serialized, all that is actually stored is Name and UseUserOverride. Yalnızca Name aynı anlamı olan bir ortamda başarıyla serileştirilir.It is successfully de-serialized only in an environment where that Name has the same meaning. Aşağıdaki üç örnek neden her zaman durum olmadığı gösterilmektedir:The following three examples show why this is not always the case:

  • CultureTypes Özellik değeri CultureTypes.InstalledWin32Culturesve bu kültür ilk olarak Windows işletim sisteminin belirli bir sürümünde sunuldıysa, Windows 'un önceki bir sürümünde serisini kaldırmak mümkün değildir.If the CultureTypes property value is CultureTypes.InstalledWin32Cultures, and if that culture was first introduced in a particular version of the Windows operating system, it is not possible to deserialize it on an earlier version of Windows. Örneğin, bir kültür Windows 10 ' da tanıtıldıysa, Windows 8 ' de seri durumdan çıkarılamaz.For example, if a culture was introduced in Windows 10, it cannot be deserialized on Windows 8.

  • CultureTypes değeri CultureTypes.UserCustomCultureve üzerinde seri hale getirilme durumunda olan bilgisayarda bu kullanıcı özel kültürü yüklü değilse, serisini kaldırmak mümkün değildir.If the CultureTypes value is CultureTypes.UserCustomCulture, and the computer on which it is de-serialized does not have this user custom culture installed, it is not possible to deserialize it.

  • CultureTypes değeri CultureTypes.ReplacementCultures, ve onun seri hale getirilemediği bilgisayarın bu değiştirme kültürü yoksa, aynı özelliklerin tümünü değil, aynı ada sahip değildir.If the CultureTypes value is CultureTypes.ReplacementCultures, and the computer on which it is de-serialized does not have this replacement culture, it de-serializes to the same name, but not all of the same characteristics. Örneğin, en-US bilgisayarı B bilgisayarında bir değiştirme kültürü ise ve bu kültüre başvuran CultureInfo bir nesne B bilgisayarında A ve yeniden serileştiriliyorsa, kültürün özel özelliklerinin hiçbiri aktarılmaz.For example, if en-US is a replacement culture on computer A, but not on computer B, and if a CultureInfo object referring to this culture is serialized on computer A and de-serialized on computer B, then none of the custom characteristics of the culture are transmitted. Kültür başarıyla serileştirir, ancak farklı anlamdadır.The culture deserializes successfully, but with a different meaning.

Denetim Masası geçersiz kılmalarıControl Panel overrides

Kullanıcı, Denetim Masası 'nın bölge ve dil seçenekleri bölümü aracılığıyla geçerli Windows kültürüyle ilişkili bazı değerleri geçersiz kılmayı seçebilir.The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. Örneğin, Kullanıcı, tarihi farklı bir biçimde görüntülemeyi veya kültür için varsayılan değer dışında bir para birimi kullanmayı seçebilir.For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture. Genel olarak, uygulamalarınız bu kullanıcı geçersiz kılmalarını dikkate almalıdır.In general, your applications should honor these user overrides.

UseUserOverride true ve belirtilen kültür Windows 'un geçerli kültürüyle eşleşiyorsa CultureInfo, DateTimeFormat özelliği tarafından döndürülen DateTimeFormatInfo örneğinin özelliklerine yönelik Kullanıcı ayarları ve NumberFormatInfo özelliği tarafından döndürülen NumberFormat örneğinin özellikleri dahil olmak üzere bu geçersiz kılmaları kullanır.If UseUserOverride is true and the specified culture matches the current culture of Windows, the CultureInfo uses those overrides, including user settings for the properties of the DateTimeFormatInfo instance returned by the DateTimeFormat property, and the properties of the NumberFormatInfo instance returned by the NumberFormat property. Kullanıcı ayarları CultureInfoilişkili kültür ile uyumsuzsa, örneğin, seçili takvim OptionalCalendarsbiri değilse, yöntemlerin sonuçları ve özelliklerin değerleri tanımsızdır.If the user settings are incompatible with the culture associated with the CultureInfo, for example, if the selected calendar is not one of the OptionalCalendars, the results of the methods and the values of the properties are undefined.

Alternatif sıralama düzenleriAlternate sort orders

Bazı kültürler birden fazla sıralama düzenini destekler.Some cultures support more than one sort order. Örnek:For example:

  • Ispanyolca (Ispanya) kültürünün iki sıralama siparişi vardır: varsayılan Uluslararası sıralama düzeni ve geleneksel sıralama düzeni.The Spanish (Spain) culture has two sort orders: the default international sort order, and the traditional sort order. ES-ES kültür adına sahip bir CultureInfo nesnesi örneğini oluşturduğunuzda, Uluslararası sıralama düzeni kullanılır.When you instantiate a CultureInfo object with the es-ES culture name, the international sort order is used. ES-ES-tradnl kültür adı ile bir CultureInfo nesnesi örneğini oluşturduğunuzda geleneksel sıralama düzeni kullanılır.When you instantiate a CultureInfo object with the es-ES-tradnl culture name, the traditional sort order is used.

  • Zh-CN (Çince (Basitleştirilmiş, ÇHC)) kültürü iki sıralama düzeni destekler: telaffuz (varsayılan) ve vuruş sayısına göre.The zh-CN (Chinese (Simplified, PRC)) culture supports two sort orders: by pronunciation (the default) and by stroke count. Zh-CN kültür adı ile bir CultureInfo nesnesi örneğini başlattığınızda, varsayılan sıralama düzeni kullanılır.When you instantiate a CultureInfo object with the zh-CN culture name, the default sort order is used. 0x00020804 yerel tanımlayıcısına sahip bir CultureInfo nesnesi örneklediğinizde, dizeler vuruş sayısına göre sıralanır.When you instantiate a CultureInfo object with a local identifier of 0x00020804, strings are sorted by stroke count.

Aşağıdaki tabloda alternatif sıralama düzenleri ve varsayılan ve alternatif sıralama emirlerinin tanımlayıcıları listelenmektedir.The following table lists the cultures that support alternate sort orders and the identifiers for the default and alternate sort orders.

Kültür adıCulture name KültürCulture Varsayılan sıralama adı ve tanımlayıcıDefault sort name and identifier Alternatif sıralama adı ve tanımlayıcıAlternate sort name and identifier
es-ESes-ES İspanyolca (İspanya)Spanish (Spain) Uluslararası: 0x00000C0AInternational: 0x00000C0A Geleneksel: 0x0000040ATraditional: 0x0000040A
zh-TWzh-TW Çince (Tayvan)Chinese (Taiwan) Vuruş sayısı: 0x00000404Stroke Count: 0x00000404 Bopomofo: 0x00030404Bopomofo: 0x00030404
zh-CNzh-CN Çince (ÇHC)Chinese (PRC) Söyleniş: 0x00000804Pronunciation: 0x00000804 Vuruş sayısı: 0x00020804Stroke Count: 0x00020804
zh-HKzh-HK Çince (Hong Kong ÖİB)Chinese (Hong Kong SAR) Vuruş sayısı: 0x00000c04Stroke Count: 0x00000c04 Vuruş sayısı: 0x00020c04Stroke Count: 0x00020c04
zh-SGzh-SG Çince (Singapur)Chinese (Singapore) Söyleniş: 0x00001004Pronunciation: 0x00001004 Vuruş sayısı: 0x00021004Stroke Count: 0x00021004
zh-MOzh-MO Çince (Makau çın ÖIB)Chinese (Macao SAR) Söyleniş: 0x00001404Pronunciation: 0x00001404 Vuruş sayısı: 0x00021404Stroke Count: 0x00021404
ja-JPja-JP Japonca (Japonya)Japanese (Japan) Varsayılan: 0x00000411Default: 0x00000411 Unicode: 0x00010411Unicode: 0x00010411
ko-KRko-KR Korece (Güney Kore)Korean (Korea) Varsayılan: 0x00000412Default: 0x00000412 Korece Xwansung-Unicode: 0x00010412Korean Xwansung - Unicode: 0x00010412
de-DEde-DE Almanca (Almanya)German (Germany) Sözlük: 0x00000407Dictionary: 0x00000407 Telefon defteri sıralaması: 0x00010407Phone Book Sort DIN: 0x00010407
hu-HUhu-HU Macarca (Macaristan)Hungarian (Hungary) Varsayılan: 0x0000040eDefault: 0x0000040e Teknik sıralama: 0x0001040eTechnical Sort: 0x0001040e
ka-GEka-GE Gürcüce (Gürcistan)Georgian (Georgia) Geleneksel: 0x00000437Traditional: 0x00000437 Modern sıralama: 0x00010437Modern Sort: 0x00010437

Geçerli kültür ve UWP uygulamalarıThe current culture and UWP apps

Evrensel Windows Platformu (UWP) uygulamalarında, CurrentCulture ve CurrentUICulture özellikleri, .NET Framework ve .NET Core uygulamalarında olduğu gibi, salt yazılır.In Universal Windows Platform (UWP) apps, the CurrentCulture and CurrentUICulture properties are read-write, just as they are in .NET Framework and .NET Core apps. Ancak, UWP uygulamaları tek bir kültürü algılar.However, UWP apps recognize a single culture. CurrentCulture ve CurrentUICulture özellikleri, Windows. ApplicationModel. resources. Core. ResourceManager. DefaultContext. Languages koleksiyonundaki ilk değere eşlenir.The CurrentCulture and CurrentUICulture properties map to the first value in the Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages collection.

.NET Framework ve .NET Core uygulamalarında, geçerli kültür iş parçacığı başına ayardır ve CurrentCulture ve CurrentUICulture özellikleri yalnızca geçerli iş parçacığının kültür ve Kullanıcı Arabirimi kültürünü yansıtır.In .NET Framework and .NET Core apps, the current culture is a per-thread setting, and the CurrentCulture and CurrentUICulture properties reflect the culture and UI culture of the current thread only. UWP uygulamalarında geçerli kültür, genel bir ayar olan Windows. ApplicationModel. resources. Core. ResourceManager. DefaultContext. Languages koleksiyonuyla eşlenir.In UWP apps, the current culture maps to the Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages collection, which is a global setting. CurrentCulture veya CurrentUICulture özelliğinin ayarlanması tüm uygulamanın kültürünü değiştirir; Kültür, iş parçacığı başına temelinde ayarlanamaz.Setting the CurrentCulture or CurrentUICulture property changes the culture of the entire app; culture cannot be set on a per-thread basis.

Oluşturucular

CultureInfo(Int32)

Kültür tanımlayıcısı tarafından belirtilen kültürü temel alan CultureInfo sınıfının yeni bir örneğini başlatır.Initializes a new instance of the CultureInfo class based on the culture specified by the culture identifier.

CultureInfo(Int32, Boolean)

Kültür tanımlayıcısı tarafından belirtilen kültürü temel alan CultureInfo sınıfının yeni bir örneğini başlatır ve kullanıcının seçtiği kültür ayarlarının sistemden kullanılıp kullanılmayacağını belirten Boole değeri.Initializes a new instance of the CultureInfo class based on the culture specified by the culture identifier and on the Boolean that specifies whether to use the user-selected culture settings from the system.

CultureInfo(String)

Ada göre belirtilen kültürü temel alan CultureInfo sınıfının yeni bir örneğini başlatır.Initializes a new instance of the CultureInfo class based on the culture specified by name.

CultureInfo(String, Boolean)

Ada göre belirtilen kültürü temel alan CultureInfo sınıfının yeni bir örneğini başlatır ve kullanıcının seçtiği kültür ayarlarının sistemden kullanılıp kullanılmayacağını belirten Boole değeri.Initializes a new instance of the CultureInfo class based on the culture specified by name and on the Boolean that specifies whether to use the user-selected culture settings from the system.

Özellikler

Calendar

Kültür tarafından kullanılan varsayılan takvimi alır.Gets the default calendar used by the culture.

CompareInfo

Kültür için dizelerin nasıl karşılaştırılacağını tanımlayan CompareInfo alır.Gets the CompareInfo that defines how to compare strings for the culture.

CultureTypes

Geçerli CultureInfo nesnesine ait kültür türlerini alır.Gets the culture types that pertain to the current CultureInfo object.

CurrentCulture

Geçerli iş parçacığı tarafından kullanılan kültürü temsil eden CultureInfo nesnesini alır veya ayarlar.Gets or sets the CultureInfo object that represents the culture used by the current thread.

CurrentUICulture

Çalışma zamanında kültüre özgü kaynakları aramak için Kaynak Yöneticisi tarafından kullanılan geçerli kullanıcı Arabirimi kültürünü temsil eden CultureInfo nesnesini alır veya ayarlar.Gets or sets the CultureInfo object that represents the current user interface culture used by the Resource Manager to look up culture-specific resources at run time.

DateTimeFormat

Tarih ve saatleri görüntülemek için uygun biçimi tanımlayan bir DateTimeFormatInfo alır veya ayarlar.Gets or sets a DateTimeFormatInfo that defines the culturally appropriate format of displaying dates and times.

DefaultThreadCurrentCulture

Geçerli uygulama etki alanındaki iş parçacıkları için varsayılan kültürü alır veya ayarlar.Gets or sets the default culture for threads in the current application domain.

DefaultThreadCurrentUICulture

Geçerli uygulama etki alanındaki iş parçacıkları için varsayılan UI kültürünü alır veya ayarlar.Gets or sets the default UI culture for threads in the current application domain.

DisplayName

Yerelleştirilmiş tam kültür adını alır.Gets the full localized culture name.

EnglishName

Kültür adını languagefull [Country/Regionfull] biçiminde İngilizce olarak alır.Gets the culture name in the format languagefull [country/regionfull] in English.

IetfLanguageTag

Kullanım dışı.Deprecated. Bir dil için RFC 4646 standart kimliğini alır.Gets the RFC 4646 standard identification for a language.

InstalledUICulture

İşletim sistemiyle yüklenen kültürü temsil eden CultureInfo alır.Gets the CultureInfo that represents the culture installed with the operating system.

InvariantCulture

Kültüre bağımsız (Sabit) nesne CultureInfo alır.Gets the CultureInfo object that is culture-independent (invariant).

IsNeutralCulture

Geçerli CultureInfo nötr kültürü temsil edip etmediğini gösteren bir değer alır.Gets a value indicating whether the current CultureInfo represents a neutral culture.

IsReadOnly

Geçerli CultureInfo salt okunurdur olduğunu gösteren bir değer alır.Gets a value indicating whether the current CultureInfo is read-only.

KeyboardLayoutId

Etkin giriş yerel ayar tanımlayıcısını alır.Gets the active input locale identifier.

LCID

Geçerli CultureInfoiçin kültür tanımlayıcısını alır.Gets the culture identifier for the current CultureInfo.

Name

Languagecode2-Country/regioncode2biçimindeki kültür adını alır.Gets the culture name in the format languagecode2-country/regioncode2.

NativeName

Kültür, dil, ülke/bölge ve isteğe bağlı komut dosyası, kültürün görüntülenmek üzere ayarlandığı kültür adını alır.Gets the culture name, consisting of the language, the country/region, and the optional script, that the culture is set to display.

NumberFormat

Sayıları, para birimini ve yüzdeyi görüntülemek için uygun biçimi tanımlayan bir NumberFormatInfo alır veya ayarlar.Gets or sets a NumberFormatInfo that defines the culturally appropriate format of displaying numbers, currency, and percentage.

OptionalCalendars

Kültür tarafından kullanılabilecek takvimlerin listesini alır.Gets the list of calendars that can be used by the culture.

Parent

Geçerli CultureInfoüst kültürünü temsil eden CultureInfo alır.Gets the CultureInfo that represents the parent culture of the current CultureInfo.

TextInfo

Kültür ile ilişkili yazma sistemini tanımlayan TextInfo alır.Gets the TextInfo that defines the writing system associated with the culture.

ThreeLetterISOLanguageName

Geçerli CultureInfodile ait ISO 639-2 üç harfli kodunu alır.Gets the ISO 639-2 three-letter code for the language of the current CultureInfo.

ThreeLetterWindowsLanguageName

Windows API 'sinde tanımlanan dilin üç harfli kodunu alır.Gets the three-letter code for the language as defined in the Windows API.

TwoLetterISOLanguageName

Geçerli CultureInfodilinin ISO 639-1 iki harfli kodunu alır.Gets the ISO 639-1 two-letter code for the language of the current CultureInfo.

UseUserOverride

Geçerli CultureInfo nesnesinin kullanıcı tarafından seçilen kültür ayarlarını kullanıp kullanmadığını gösteren bir değer alır.Gets a value indicating whether the current CultureInfo object uses the user-selected culture settings.

Yöntemler

ClearCachedData()

, Kültüre ilişkin önbelleğe alınmış bilgileri yeniler.Refreshes cached culture-related information.

Clone()

Geçerli CultureInfobir kopyasını oluşturur.Creates a copy of the current CultureInfo.

CreateSpecificCulture(String)

Belirtilen adla ilişkili belirli kültürü temsil eden bir CultureInfo oluşturur.Creates a CultureInfo that represents the specific culture that is associated with the specified name.

Equals(Object)

Belirtilen nesnenin geçerli CultureInfokültür olup olmadığını belirler.Determines whether the specified object is the same culture as the current CultureInfo.

GetConsoleFallbackUICulture()

Varsayılan grafik kullanıcı arabirimi kültürü uygun değilse konsol uygulamaları için uygun olan alternatif bir kullanıcı arabirimi kültürü alır.Gets an alternate user interface culture suitable for console applications when the default graphic user interface culture is unsuitable.

GetCultureInfo(Int32)

Belirtilen kültür tanımlayıcısını kullanarak bir kültürün önbelleğe alınmış, salt okunurdur örneğini alır.Retrieves a cached, read-only instance of a culture by using the specified culture identifier.

GetCultureInfo(String)

Belirtilen kültür adını kullanarak bir kültürün önbelleğe alınmış, salt okunurdur örneğini alır.Retrieves a cached, read-only instance of a culture using the specified culture name.

GetCultureInfo(String, String)

Bir kültürün önbelleğe alınmış, salt okunurdur bir örneğini alır.Retrieves a cached, read-only instance of a culture. Parametreler, başka bir kültür tarafından belirtilen TextInfo ve CompareInfo nesneleri ile başlatılan bir kültür belirtir.Parameters specify a culture that is initialized with the TextInfo and CompareInfo objects specified by another culture.

GetCultureInfoByIetfLanguageTag(String)

Kullanım dışı.Deprecated. Belirtilen RFC 4646 Language etiketi tarafından tanımlanan dil özelliklerine sahip salt okunurdur CultureInfo nesnesini alır.Retrieves a read-only CultureInfo object having linguistic characteristics that are identified by the specified RFC 4646 language tag.

GetCultures(CultureTypes)

Belirtilen CultureTypes parametresine göre filtrelenen desteklenen kültürlerin listesini alır.Gets the list of supported cultures filtered by the specified CultureTypes parameter.

GetFormat(Type)

Belirtilen türün nasıl biçimlendirileceğini tanımlayan bir nesne alır.Gets an object that defines how to format the specified type.

GetHashCode()

, Karma algoritmalar ve karma tablo gibi veri yapılarına uygun geçerli CultureInfoiçin bir karma işlev işlevi görür.Serves as a hash function for the current CultureInfo, suitable for hashing algorithms and data structures, such as a hash table.

GetType()

Geçerli örneğin Type alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
MemberwiseClone()

Geçerli Objectbasit bir kopyasını oluşturur.Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
ReadOnly(CultureInfo)

Belirtilen CultureInfo nesnesinin etrafında salt okunurdur bir sarmalayıcı döndürür.Returns a read-only wrapper around the specified CultureInfo object.

ToString()

Languagecode2-Country/regioncode2biçimindeki geçerli CultureInfo adını içeren bir dize döndürür.Returns a string containing the name of the current CultureInfo in the format languagecode2-country/regioncode2.

Şunlara uygulanır

Ayrıca bkz.