использование ключевого слова «using» в c # [duplicate]

ключевое слово using может использоваться для импорта (связывания) пространства имен или библиотеки с нашей программой. Таким образом, мы можем использовать функции, доступные в этих библиотеках, в нашей программе. Это что-то вроде ссылки

Пример: using System.IO

Это означает, что мы собираемся использовать некоторые функции, присутствующие в этой библиотеке

Вы можете написать свою собственную библиотеку и импортировать ее с помощью оператора using. Пример:

namespace MyProject.MyNamspace
{
 public class MyCustomClass
 {
  public static string MyFunctionToSmile()
  {
   return "He he he heeee";
  }   
}

}

и на странице ur c # используйте эту

using MyProject.MyNamspace

public class MyClass
{
 protected void Page_Load(object sender, EventArgs e)
 {
  Response.Write(MyCustomClass.MyFunctionToSmile());
 } 
}

Круто ...!

использование может использоваться для:

• «импорта» пространств имен, то есть использования их
• создания псевдонима для типа (например, typedef ] еще в дни c ++)
• удаляйте объект сразу после его использования

Существует два разных использования ключевого слова с использованием в C #:

1. Для объявления неявной области пакета, например, «using System»;
2. Для вызова метода Dispose () объекта IDisposable.

В последнем случае using (myVar) {} является сокращением для:

IDisposable disposable = (IDisposable)myVar;
try
{
   // your code here
}
finally
{
   if (disposable != null)
      disposable.Dispose();
}

Есть два варианта использования ключевого слова using:

• как директива using , которая разрешает использование типов в пространстве имен. Например: с использованием System.Web

• в качестве оператора using , что возможно только для типов, унаследованных от IDisposable . Это автоматически вызывает метод Dispose () объекта после того, как оператор using выходит за пределы области видимости, поэтому вам не нужно беспокоиться об автоматическом вызове этого метода самостоятельно или вызове Close () для подключений к базе данных, например:

  using (MySqlConnection connection = new MySqlConnection ()) { // .. }

См .:
с использованием оператора
с использованием директивы

MSDN - лучший выбор

http://msdn.microsoft.com/en-us/library/yh598w02%28VS.80%29.aspx

.. но там есть много ресурсов ..

http://blogs.msdn.com/cyrusn/archive/2005/05/10/415956.aspx

"using" ключевое слово может также может использоваться для создания псевдонимов типов. Здесь Item - это псевдоним словаря. Такой подход может сэкономить вам немного времени при вводе:)

Например,

using Item = System.Collections.Generic.Dictionary<string, string>;
namespace Sample
{
    using Records = Dictionary<int, Item>;
    public class Controller
    {
      Records recordDictionary = new Records();
    }
}

Есть три использует:

• В качестве директивы (два использования) для импорта пространств имен и типов псевдонимов
• В качестве инструкции для удаления объектов IDisposable в конце области

Я не верю, что может объяснить более четко, чем в общих чертах статьи MSDN. Если у вас возникли проблемы с их пониманием, возможно, вам лучше задать более конкретный вопрос о деталях, которых вы не понимаете.

Есть два использования ключевого слова.

Первое - когда вам лень вводить System.Web.UI.WebControls.TextBox , которое вы добавляете используя System.Web.UI.WebControls в верхней части файла кода и впредь просто пишите TextBox . Это все, что он делает - сокращает код, который вам нужно написать (и упрощает его чтение).

Другой имеет отношение к интерфейсу IDisposable . Этот интерфейс предназначен для объектов, которые необходимо очистить после того, как вы закончите их использовать. Например, файлы, которые нужно закрыть, или соединения с БД, и тому подобное. Вы можете просто вызвать метод Dispose () , где бы это ни было, но это упростит задачу. Вкратце, это:

using (var X = new MyObject())
{
    // Code goes here
}

эквивалентно этому:

var X = new MyObject();
try
{
    // Code goes here   
}
finally
{
    if ( X != null )
        X.Dispose();
}

И снова - это ' Сокращение для фрагмента кода, который гарантирует, что в любом случае будет вызван метод Dispose () . Даже когда ваш код генерирует исключение или вы возвращаете из метода, метод Dispose () будет вызван. Это гарантирует, что вы случайно не оставите файлы открытыми или что-то в этом роде.

В общем, если вы когда-либо используете объект, реализующий интерфейс IDisposable , поместите его в с помощью блока .

Я полагаю, вы говорите об блоке управления using, а не об операторе using [namespace]. По сути, ключевое слово - это синтаксический сахар для безопасной инициализации и удаления объектов. Он работает с любым объектом, реализующим IDisposable. Следующее:

using(MyType obj = new MyType())
{
  ... do stuff.
}

эквивалентно:

MyType obj = new MyType();
try
{
  .... do stuff
}
finally
{
  if(obj != null)
  {
      obj.Dispose();
  }
}

использование имеет два значения в C #:

• использование для IDisposable означает, что когда блок использования заканчивается Dispose метод будет вызван.
• использование для пространства имен означает, что типы из импортированного пространства имен будут ссылаться в коде.

Базовый пример того, как работает использование блока:

A " dummy "одноразовый класс:

public class DisposableClass : IDisposable
{
    public static bool WasDisposed { get; private set;}

    public void Dispose()
    {
        WasDisposed = true;
    }
}

Какой-то очень простой код, который демонстрирует, когда вызывается Dispose:

[Test]
public void DisposeSample()
{
    using (var disposableClass = new DisposableClass())
    {
        Assert.IsFalse(DisposableClass.WasDisposed);
    }

    Assert.IsTrue(DisposableClass.WasDisposed);
}

Уверен, что где-то будет дубликат этого ... однако в Короче говоря, using используются для определения объема создаваемого объекта. Объект удаляется после выхода из блока using, т.е. Dispose вызывается автоматически.

См. using Statement (C #) для получения дополнительных сведений.

Это дает вам простой способ очистить ресурсы после того, как вы закончите с ними. С конструкцией using , когда вы закончите использовать ресурсы, они автоматически освобождаются. Он даже очищает ресурсы в случае исключения.