Какой метод сортировки наиболее подходит для параллельной обработки?

Ответы на этот вопрос больше, чем немного перепутали.

заголовок спрашивает о распоряжении, но тогда говорит, что они хотят память назад сразу.

.Net , справился , что означает, что, когда Вы пишете.Net приложения, Вы не должны волноваться о памяти непосредственно, стоимость - то, что Вы не имеете прямого контроля над памятью также.

.Net решает, когда лучше мыться и свободная память, не Вы как.Net кодер.

Эти Dispose способ сказать.Net, что Вы сделаны с чем-то, но он на самом деле не освободит память, пока это не будет наилучшее время, чтобы сделать так.

В основном.Net на самом деле соберет память назад, когда для него будет самым легким сделать так - это очень хорошо в решении когда. Если Вы не пишете что-то очень интенсивно использующее память, Вы обычно не должны отвергать его (это - часть причины, которая игры не часто пишутся в.Net все же - им нужен полный контроль)

В.Net, который можно использовать GC.Collect() для принуждения его к сразу, но это - почти всегда плохая практика. Если.Net еще не очистил его, который означает, что это не особенно хорошее время для него, чтобы сделать так.

GC.Collect() берет объекты, которые.Net определяет, как покончено. Если Вы не расположили объект, которому нужен он.Net может решить сохранить тот объект. Это означает, что GC.Collect() является только эффективным, если Вы правильно реализуете свои доступные экземпляры.

GC.Collect() не замена для того, чтобы правильно использовать IDisposable.

Так Располагают, и память непосредственно не связаны, но они не должны быть. Правильно расположение будет делать Ваши.Net приложения более эффективными и поэтому использовать меньше памяти все же.

99% времени в.Net следующее является лучшей практикой:

Правило 1: , Если Вы ни с чем не имеете дело неуправляемый или это реализует IDisposable, тогда не волнуются о, Располагают.

Правило 2: , Если у Вас есть локальная переменная, которая реализует IDisposable, удостоверяются, что Вы избавляетесь от него в текущей области:

//using is best practice
using( SqlConnection con = new SqlConnection("my con str" ) )
{
    //do stuff
} 

//this is what 'using' actually compiles to:
SqlConnection con = new SqlConnection("my con str" ) ;
try
{
    //do stuff
}
finally
{
    con.Dispose();
}

Правило 3: , Если класс имеет свойство или членскую переменную, которая реализует IDisposable тогда, что класс должен реализовать IDisposable также. В том классе Располагают метод, можно также избавиться свойств IDisposable:

//rather basic example
public sealed MyClass :
   IDisposable
{   
    //this connection is disposable
    public SqlConnection MyConnection { get; set; }

    //make sure this gets rid of it too
    public Dispose() 
    {
        //if we still have a connection dispose it
        if( MyConnection != null )
            MyConnection.Dispose();

        //note that the connection might have already been disposed
        //always write disposals so that they can be called again
    }
}

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

Правило 4: , Если класс использует неуправляемый , ресурс тогда реализует IDispose , и добавляют финализатор.

.Net ничего не может сделать с неуправляемый ресурс, поэтому теперь мы говорим о памяти. Если Вы не чистите его, можно получить утечку памяти.

Расположить метод должен иметь дело и с [1 115], справился и неуправляемый ресурсы.

~MyClass()
{
    //calls a protected method 
    //the false tells this method
    //not to bother with managed
    //resources
    this.Dispose(false);
}

public void Dispose()
{
    //calls the same method
    //passed true to tell it to
    //clean up managed and unmanaged 
    this.Dispose(true);

    //as dispose has been correctly
    //called we don't need the 

    //'backup' finaliser
    GC.SuppressFinalize(this);
}

protected virtual void Dispose(bool disposing)
{
    //check this hasn't been called already
    //remember that Dispose can be called again
    if (!disposed)
    {
        //this is passed true in the regular Dispose
        if (disposing)
        {
            // Dispose managed resources here.
        }

        //both regular Dispose and the finaliser
        //will hit this code
        // Dispose unmanaged resources here.
    }

    disposed = true;
}