yönergesi `using`

2025-01-27

yönergesi, using bir ad alanında tanımlanan türleri, bu türün tam ad alanını belirtmeden kullanmanıza olanak tanır. Yönerge, using aşağıdaki örnekte gösterildiği gibi temel biçiminde tek bir ad alanından tüm türleri içeri aktarır:

using System.Text;

Yönergeye using iki değiştirici uygulayabilirsiniz:

Değiştirici, global projenizdeki her kaynak dosyaya aynı yönergeyi eklemeyle aynı using etkiye sahiptir.
Değiştiricistatic, static üyeleri ve iç içe yerleştirilmiş türleri bir ad alanında tüm türleri içeri aktarmak yerine tek bir türden içeri aktarır.

Bir türdeki statik üyeleri projenizdeki tüm kaynak dosyalara aktarmak için her iki değiştiriciyi de birleştirebilirsiniz.

Ayrıca, bir ad alanı veya using alias yönergesi olan bir tür için de diğer ad oluşturabilirsiniz.

using Project = PC.MyCompany.Project;

Diğer ad kullanma yönergesinde globaldeğiştiriciyi kullanabilirsiniz.

Not

Anahtar using sözcüğü, dosyalar ve yazı tipleri gibi nesnelerin doğru şekilde işlenmesine yardımcı using olan deyimler oluşturmak IDisposable için de kullanılır. deyimi hakkında daha fazla bilgi için bkzusing. deyimi.using

Değiştiricisi olmayan bir using yönergenin global kapsamı, göründüğü dosyadır.

yönergesi global using tüm ad alanı ve tür bildirimlerinden önce görünmelidir. Tüm genel kullanım yönergeleri, herhangi bir genel using olmayan yönergeden önce bir kaynak dosyada görünmelidir.

Diğer using yönergeler görünebilir:

Kaynak kod dosyasının başında, herhangi bir ad alanı veya tür bildirimlerinden önce.
Engellenen kapsamlı herhangi bir ad alanında, ancak bu ad alanında bildirilen ad alanları veya türlerden önce.

Aksi takdirde bir derleyici hatası oluşturulur.

Ad alanını belirtmek zorunda kalmadan ad alanında türleri kullanmak için bir using yönerge oluşturun. Yönerge using , belirttiğiniz ad alanında iç içe yerleştirilmiş ad alanlarına erişmenizi sağlamaz. Ad alanları iki kategoriye ayrılır: kullanıcı tanımlı ve sistem tanımlı. Kullanıcı tanımlı ad alanları, kodunuzda tanımlanan ad alanlarıdır. Sistem tanımlı ad alanlarının listesi için bkz . .NET API Browser.

Değiştirici `global`

global değiştiricisini bir using yönergesine eklemek, tüm dosyaların (genellikle bir projede) derlenmesinde "using" ifadesinin uygulanacağı anlamına gelir.

global using <fully-qualified-namespace>;

Burada tam-nitelenmiş-ad alanı , ad alanı belirtilmeden türlerine başvurulabilen ad alanının tam adıdır.

Genel bir using yönergesi herhangi bir kaynak kod dosyasının başında görünebilir. Tek bir dosyadaki tüm global using yönergelerin önce görünmesi gerekir:

Değiştiricisi olmayan using tüm global yönergeler.
Dosyadaki tüm ad alanı ve tür bildirimleri.

Herhangi bir kaynak dosyaya yönergeler ekleyebilirsiniz global using . Genellikle, bunları tek bir konumda tutmak istersiniz. Yönergelerin global using sırası, tek bir dosyada veya dosyalar arasında önemli değildir.

Değiştirici global , değiştirici ile static birleştirilebilir. Değiştiriciglobal, using alias yönergesine uygulanabilir. Her iki durumda da yönergenin kapsamı geçerli derlemedeki tüm dosyalardır. Aşağıdaki örnek, projenizdeki tüm dosyalarda System.Math içinde bildirilen tüm yöntemlerin kullanılmasını sağlar:

global using static System.Math;

Proje dosyanıza bir öğe ekleyerek genel olarak bir <Using> ad alanı da ekleyebilirsiniz; örneğin, <Using Include="My.Awesome.Namespace" />. Daha fazla bilgi için bkz <Using> . öğe.

Çözümleyiciler, farklı konumlardaki yönergeleri kullanarak yinelenen global tanılamalar oluşturur. Bu aynı çözümleyiciler, bir ad alanı için yönerge using ekleyip eklemediğiniz veya using yönergesinde zaten başvuruda bulunduğunu belirten bir global tür olup olmadığını da size bildirir. Projedeki tek bir dosyada bir arada tutarak kullanımınızı global yönetmeyi daha kolay bulabilirsiniz.

Önemli

.NET 6 için C# şablonları en üst düzey deyimleri kullanır. .NET 6'ya zaten yükselttiyseniz uygulamanız bu makaledeki kodla eşleşmeyebilir. Daha fazla bilgi için Yeni C# şablonları en üst düzey deyimleri oluşturma makalesine bakın

.NET 6 SDK'sı, aşağıdaki SDK'ları kullanan projeler için bir dizi örtükglobal using yönerge de ekler:

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Bu örtük global using yönergeler, proje türü için en yaygın ad alanlarını içerir.

Daha fazla bilgi için Örtük kullanım yönergeleri makalesine bakın

Değiştirici `static`

yönergesi using static , bir tür adı belirtmeden erişebileceğiniz statik üyeleri ve iç içe türleri olan bir türü adlandırır. Söz dizimi şöyledir:

using static <fully-qualified-type-name>;

<fully-qualified-type-name>, statik üyelerine ve iç içe türlerine bir tür adı belirtilmeden başvurulabilen türün adıdır. Tam tür adı (tür adıyla birlikte tam ad alanı adı) sağlamazsanız C# derleyici hatası CS0246 oluşturur: "'tür/ad alanı' türü veya ad alanı adı bulunamadı (kullanma yönergesi veya derleme başvurusu eksik mi?)".

yönergesi, using static örnek üyeleri de olsa statik üyeleri (veya iç içe türler) olan herhangi bir tür için geçerlidir. Ancak, örnek üyeleri yalnızca tür örneği aracılığıyla çağrılabilir.

Türün statik üyelerine, erişimi tür adıyla nitelemeniz gerekmeden erişebilirsiniz:

using static System.Console;
using static System.Math;
class Program
{
    static void Main()
    {
        WriteLine(Sqrt(3*3 + 4*4));
    }
}

Normalde, statik üyeyi çağırdığınızda, üye adıyla birlikte tür adını da sağlarsınız. Türün üyelerini çağırmak için aynı tür adının tekrar tekrar girilmesi, ayrıntılı ve belirsiz bir koda neden olabilir. Örneğin, bir Circle sınıfın aşağıdaki tanımı sınıfın birçok üyesine başvurur Math .

using System;

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * Math.PI; }
   }

   public double Area
   {
      get { return Math.PI * Math.Pow(Radius, 2); }
   }
}

Bir üyeye her başvurulsa sınıfına Math açıkça başvurma gereksinimi ortadan kaldırılarak yönergesi using static daha temiz kod üretir:

using System;
using static System.Math;

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * PI; }
   }

   public double Area
   {
      get { return PI * Pow(Radius, 2); }
   }
}

using static yalnızca belirtilen türde bildirilen erişilebilir statik üyeleri ve iç içe türleri içeri aktarır. Devralınan üyeler içeri aktarılamaz. Visual Basic modülleri de dahil olmak üzere bir yönerge ile herhangi bir using static adlandırılmış türden içeri aktarabilirsiniz. F# üst düzey işlevleri meta verilerde adı geçerli bir C# tanımlayıcısı olan adlandırılmış bir türün statik üyeleri olarak görünüyorsa, F# işlevleri içeri aktarılabilir.

using static belirtilen türde bildirilen uzantı yöntemlerini, uzantı yöntemi araması için kullanılabilir hale getirir. Ancak, uzantı yöntemlerinin adları kodda nitelenmemiş başvuru için kapsama aktarılmaz.

Aynı derleme birimi veya ad alanı içindeki farklı yönergeler tarafından farklı using static türlerden içeri aktarılan aynı ada sahip yöntemler bir yöntem grubu oluşturur. Bu yöntem grupları içinde aşırı yükleme çözümlemesi normal C# kurallarına uyar.

Aşağıdaki örnek, , using staticve sınıflarının statik üyelerini Consoletür adlarını belirtmek zorunda kalmadan kullanılabilir hale getirmek için yönergesini kullanır Math String.

using System;
using static System.Console;
using static System.Math;
using static System.String;

class Program
{
   static void Main()
   {
      Write("Enter a circle's radius: ");
      var input = ReadLine();
      if (!IsNullOrEmpty(input) && double.TryParse(input, out var radius)) {
         var c = new Circle(radius);

         string s = "\nInformation about the circle:\n";
         s = s + Format("   Radius: {0:N2}\n", c.Radius);
         s = s + Format("   Diameter: {0:N2}\n", c.Diameter);
         s = s + Format("   Circumference: {0:N2}\n", c.Circumference);
         s = s + Format("   Area: {0:N2}\n", c.Area);
         WriteLine(s);
      }
      else {
         WriteLine("Invalid input...");
      }
   }
}

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * PI; }
   }

   public double Area
   {
      get { return PI * Pow(Radius, 2); }
   }
}
// The example displays the following output:
//       Enter a circle's radius: 12.45
//
//       Information about the circle:
//          Radius: 12.45
//          Diameter: 24.90
//          Circumference: 78.23
//          Area: 486.95

Örnekte yönerge using static türüne Double de uygulanabilir. Bu yönergenin eklenmesi, bir tür adı belirtmeden yöntemini çağırmayı TryParse(String, Double) mümkün hale getirir. Ancak, tür adı olmadan kullanmak TryParse daha az okunabilir kod oluşturur, çünkü hangi sayısal türün using static yönteminin TryParse çağrıldığını belirlemek için yönergelerin denetlenmesi gerekir.

using static ayrıca türler için enum de geçerlidir. Sabit listesi ile ekleyerek using static , türü artık sabit listesi üyelerini kullanmak için gerekli değildir.

using static Color;

enum Color
{
    Red,
    Green,
    Blue
}

class Program
{
    public static void Main()
    {
        Color color = Green;
    }
}

Diğer `using` ad

Bir tanımlayıcıyı ad using alanına veya türe uygun hale getirmek için bir diğer ad yönergesi oluşturun. Herhangi bir using yönergede, ondan önce gelen yönergelerden bağımsız olarak using tam ad alanı veya türü kullanılmalıdır. Bir using yönergenin bildiriminde hiçbir using diğer ad kullanılamaz. Örneğin, aşağıdaki örnek bir derleyici hatası oluşturur:

using s = System.Text;
using s.RegularExpressions; // Generates a compiler error.

Aşağıdaki örnekte ad alanı için diğer using adın nasıl tanımlanacağı ve kullanılacağı gösterilmektedir:

namespace PC
{
    // Define an alias for the nested namespace.
    using Project = PC.MyCompany.Project;
    class A
    {
        void M()
        {
            // Use the alias
            var mc = new Project.MyClass();
        }
    }
    namespace MyCompany
    {
        namespace Project
        {
            public class MyClass { }
        }
    }
}

Using alias yönergesinin sağ tarafında açık bir genel tür olamaz. Örneğin, için bir diğer ad kullanarak oluşturamazsınız, ancak için bir List<T>diğer ad List<int>oluşturabilirsiniz.

Aşağıdaki örnekte, bir using sınıf için yönerge ve using diğer ad tanımlama gösterilmektedir:

using System;

// Using alias directive for a class.
using AliasToMyClass = NameSpace1.MyClass;

// Using alias directive for a generic class.
using UsingAlias = NameSpace2.MyClass<int>;

namespace NameSpace1
{
    public class MyClass
    {
        public override string ToString()
        {
            return "You are in NameSpace1.MyClass.";
        }
    }
}

namespace NameSpace2
{
    class MyClass<T>
    {
        public override string ToString()
        {
            return "You are in NameSpace2.MyClass.";
        }
    }
}

namespace NameSpace3
{
    class MainClass
    {
        static void Main()
        {
            var instance1 = new AliasToMyClass();
            Console.WriteLine(instance1);

            var instance2 = new UsingAlias();
            Console.WriteLine(instance2);
        }
    }
}
// Output:
//    You are in NameSpace1.MyClass.
//    You are in NameSpace2.MyClass.

C# 12'de başlayarak, tanımlama grubu türleri, işaretçi türleri ve diğer güvenli olmayan türler de dahil olmak üzere daha önce kısıtlanmış türler için diğer adlar oluşturabilirsiniz. Güncelleştirilmiş kurallar hakkında daha fazla bilgi için özellik belirtimlerine bakın.

Nitelenmiş diğer ad üyesi

Ad alanı diğer ad niteleyicisi, :: genel ad alanına veya diğer varlıklar tarafından gizlenmiş olabilecek diğer adları kullanan diğer adlara açık erişim sağlar.

, global:: belirteci izleyen ad alanı için ad alanı aramasının :: genel ad alanına göre olmasını sağlar. Aksi takdirde, belirtecin bir kullanan diğer ad olarak çözümlenmesi ve bunu izleyen :: belirtecin bu diğer ad alanında bir türe çözümlenmesi gerekir. Aşağıdaki örnekte her iki form da gösterilmektedir:

using S = System.Net.Sockets;

class A
{
    public static int x;
}

class C
{
    public void F(int A, object S)
    {
        // Use global::A.x instead of A.x
        global::A.x += A;

        // Using ::, S must resolve to a namespace alias:
        S::Socket s = S as S::Socket;

        // In this form, if S were a class, it would be a compile-time error:
        S.Socket s1 = S as S.Socket;
    }
}

C# dili belirtimi

Daha fazla bilgi için bkz. C# Dil Belirtiminde yönergeleri kullanma. Dil belirtimi, C# sözdizimi ve kullanımı için kesin bir kaynaktır.

değiştiricisini kullanarak globali hakkında daha fazla bilgi için, global kullanımları özellik belirtiminebakın.

Aracılığıyla paylaş

yönergesi using

Değiştirici global

Değiştirici static

Diğer using ad