Class Cache

Class Cache

Namespace: Aspose.Imaging
Assembly: Aspose.Imaging.dll (25.2.0)

Содержит настройки кэша.

public static class Cache

Наследование

objectCache

Унаследованные члены

object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

Примеры

Этот пример демонстрирует использование Aspose.Imaging.Cache```csharp [C#]

                                                                // По умолчанию папка кэша установлена в локальный временный каталог пользователя.
                                                                // Вы также можете указать другую папку кэша, отличную от стандартной, следующим образом:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Автоматический режим гибок и эффективен
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Значение по умолчанию равно 0, что означает отсутствие верхнего предела
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 гигабайт
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 гигабайт

                                                                // Не рекомендуется изменять следующее свойство, так как это может значительно повлиять на производительность
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // В любое время вы можете проверить, сколько байт в настоящее время выделено для памяти или диска 
                                                                // кэша, проверив следующие свойства
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Выполните обработку изображения, как показано ниже
                                                                Aspose.Imaging.ImageOptions.GifOptions options = new Aspose.Imaging.ImageOptions.GifOptions();
                                                                options.Palette = new ColorPalette(new Aspose.Imaging.Color[] { Aspose.Imaging.Color.Red, Aspose.Imaging.Color.Blue, Aspose.Imaging.Color.Black, Aspose.Imaging.Color.White });
                                                                options.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);
                                                                using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(options, 100, 100))
                                                                {
                                                                    Aspose.Imaging.Color[] pixels = new Aspose.Imaging.Color[10000];
                                                                    for (int i = 0; i < pixels.Length; i++)
                                                                    {
                                                                        pixels[i] = Aspose.Imaging.Color.White;
                                                                    }

                                                                    image.SavePixels(image.Bounds, pixels);

                                                                    // после выполнения кода выше будет выделено 40000 байт в памяти.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Свойства выделения могут использоваться для проверки, были ли все объекты Aspose.Imaging правильно освобождены.
                                                                // Если вы забыли вызвать dispose для какого-либо объекта, значения кэша будут отличаться от 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

## Свойства

### <a id="Aspose_Imaging_Cache_AllocatedDiskBytesCount"></a> AllocatedDiskBytesCount

Получает количество выделенных байт на диске.

```csharp
public static long AllocatedDiskBytesCount { get; }

Значение свойства

long

Примеры

Этот пример демонстрирует использование Aspose.Imaging.Cache```csharp [C#]

                                                                // По умолчанию папка кэша установлена в локальный временный каталог пользователя.
                                                                // Вы также можете указать другую папку кэша, отличную от стандартной, следующим образом:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Автоматический режим гибок и эффективен
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Значение по умолчанию равно 0, что означает отсутствие верхнего предела
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 гигабайт
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 гигабайт

                                                                // Не рекомендуется изменять следующее свойство, так как это может значительно повлиять на производительность
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // В любое время вы можете проверить, сколько байт в настоящее время выделено для памяти или диска 
                                                                // кэша, проверив следующие свойства
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Выполните обработку изображения, как показано ниже
                                                                Aspose.Imaging.ImageOptions.GifOptions options = new Aspose.Imaging.ImageOptions.GifOptions();
                                                                options.Palette = new ColorPalette(new Aspose.Imaging.Color[] { Aspose.Imaging.Color.Red, Aspose.Imaging.Color.Blue, Aspose.Imaging.Color.Black, Aspose.Imaging.Color.White });
                                                                options.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);
                                                                using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(options, 100, 100))
                                                                {
                                                                    Aspose.Imaging.Color[] pixels = new Aspose.Imaging.Color[10000];
                                                                    for (int i = 0; i &lt; pixels.Length; i++)
                                                                    {
                                                                        pixels[i] = Aspose.Imaging.Color.White;
                                                                    }

                                                                    image.SavePixels(image.Bounds, pixels);

                                                                    // после выполнения кода выше будет выделено 40000 байт в памяти.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Свойства выделения могут использоваться для проверки, были ли все объекты Aspose.Imaging правильно освобождены.
                                                                // Если вы забыли вызвать dispose для какого-либо объекта, значения кэша будут отличаться от 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

### <a id="Aspose_Imaging_Cache_AllocatedMemoryBytesCount"></a> AllocatedMemoryBytesCount

Получает количество выделенных байт в памяти.

```csharp
public static long AllocatedMemoryBytesCount { get; }

Значение свойства

long

Примеры

Этот пример демонстрирует использование Aspose.Imaging.Cache```csharp [C#]

                                                                // По умолчанию папка кэша установлена в локальный временный каталог пользователя.
                                                                // Вы также можете указать другую папку кэша, отличную от стандартной, следующим образом:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Автоматический режим гибок и эффективен
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Значение по умолчанию равно 0, что означает отсутствие верхнего предела
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 гигабайт
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 гигабайт

                                                                // Не рекомендуется изменять следующее свойство, так как это может значительно повлиять на производительность
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // В любое время вы можете проверить, сколько байт в настоящее время выделено для памяти или диска 
                                                                // кэша, проверив следующие свойства
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Выполните обработку изображения, как показано ниже
                                                                Aspose.Imaging.ImageOptions.GifOptions options = new Aspose.Imaging.ImageOptions.GifOptions();
                                                                options.Palette = new ColorPalette(new Aspose.Imaging.Color[] { Aspose.Imaging.Color.Red, Aspose.Imaging.Color.Blue, Aspose.Imaging.Color.Black, Aspose.Imaging.Color.White });
                                                                options.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);
                                                                using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(options, 100, 100))
                                                                {
                                                                    Aspose.Imaging.Color[] pixels = new Aspose.Imaging.Color[10000];
                                                                    for (int i = 0; i &lt; pixels.Length; i++)
                                                                    {
                                                                        pixels[i] = Aspose.Imaging.Color.White;
                                                                    }

                                                                    image.SavePixels(image.Bounds, pixels);

                                                                    // после выполнения кода выше будет выделено 40000 байт в памяти.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Свойства выделения могут использоваться для проверки, были ли все объекты Aspose.Imaging правильно освобождены.
                                                                // Если вы забыли вызвать dispose для какого-либо объекта, значения кэша будут отличаться от 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

### <a id="Aspose_Imaging_Cache_CacheFolder"></a> CacheFolder

Получает или задает папку кэша.

```csharp
public static string CacheFolder { get; set; }

Значение свойства

string

CacheType

Получает или задает схему кэша, используемую.

public static CacheType CacheType { get; set; }

Значение свойства

CacheType

Примеры

Этот пример демонстрирует использование Aspose.Imaging.Cache```csharp [C#]

                                                                // По умолчанию папка кэша установлена в локальный временный каталог пользователя.
                                                                // Вы также можете указать другую папку кэша, отличную от стандартной, следующим образом:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Автоматический режим гибок и эффективен
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Значение по умолчанию равно 0, что означает отсутствие верхнего предела
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 гигабайт
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 гигабайт

                                                                // Не рекомендуется изменять следующее свойство, так как это может значительно повлиять на производительность
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // В любое время вы можете проверить, сколько байт в настоящее время выделено для памяти или диска 
                                                                // кэша, проверив следующие свойства
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Выполните обработку изображения, как показано ниже
                                                                Aspose.Imaging.ImageOptions.GifOptions options = new Aspose.Imaging.ImageOptions.GifOptions();
                                                                options.Palette = new ColorPalette(new Aspose.Imaging.Color[] { Aspose.Imaging.Color.Red, Aspose.Imaging.Color.Blue, Aspose.Imaging.Color.Black, Aspose.Imaging.Color.White });
                                                                options.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);
                                                                using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(options, 100, 100))
                                                                {
                                                                    Aspose.Imaging.Color[] pixels = new Aspose.Imaging.Color[10000];
                                                                    for (int i = 0; i &lt; pixels.Length; i++)
                                                                    {
                                                                        pixels[i] = Aspose.Imaging.Color.White;
                                                                    }

                                                                    image.SavePixels(image.Bounds, pixels);

                                                                    // после выполнения кода выше будет выделено 40000 байт в памяти.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Свойства выделения могут использоваться для проверки, были ли все объекты Aspose.Imaging правильно освобождены.
                                                                // Если вы забыли вызвать dispose для какого-либо объекта, значения кэша будут отличаться от 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

### <a id="Aspose_Imaging_Cache_ExactReallocateOnly"></a> ExactReallocateOnly

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

```csharp
public static bool ExactReallocateOnly { get; set; }

Значение свойства

bool

Примеры

Этот пример демонстрирует использование Aspose.Imaging.Cache```csharp [C#]

                                                                // По умолчанию папка кэша установлена в локальный временный каталог пользователя.
                                                                // Вы также можете указать другую папку кэша, отличную от стандартной, следующим образом:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Автоматический режим гибок и эффективен
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Значение по умолчанию равно 0, что означает отсутствие верхнего предела
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 гигабайт
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 гигабайт

                                                                // Не рекомендуется изменять следующее свойство, так как это может значительно повлиять на производительность
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // В любое время вы можете проверить, сколько байт в настоящее время выделено для памяти или диска 
                                                                // кэша, проверив следующие свойства
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Выполните обработку изображения, как показано ниже
                                                                Aspose.Imaging.ImageOptions.GifOptions options = new Aspose.Imaging.ImageOptions.GifOptions();
                                                                options.Palette = new ColorPalette(new Aspose.Imaging.Color[] { Aspose.Imaging.Color.Red, Aspose.Imaging.Color.Blue, Aspose.Imaging.Color.Black, Aspose.Imaging.Color.White });
                                                                options.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);
                                                                using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(options, 100, 100))
                                                                {
                                                                    Aspose.Imaging.Color[] pixels = new Aspose.Imaging.Color[10000];
                                                                    for (int i = 0; i &lt; pixels.Length; i++)
                                                                    {
                                                                        pixels[i] = Aspose.Imaging.Color.White;
                                                                    }

                                                                    image.SavePixels(image.Bounds, pixels);

                                                                    // после выполнения кода выше будет выделено 40000 байт в памяти.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Свойства выделения могут использоваться для проверки, были ли все объекты Aspose.Imaging правильно освобождены.
                                                                // Если вы забыли вызвать dispose для какого-либо объекта, значения кэша будут отличаться от 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

#### Примечания

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

### <a id="Aspose_Imaging_Cache_MaxDiskSpaceForCache"></a> MaxDiskSpaceForCache

Получает или задает максимальное доступное дисковое пространство для кэша. Указанное значение - это количество мегабайт.

```csharp
public static int MaxDiskSpaceForCache { get; set; }

Значение свойства

int

Примеры

Этот пример демонстрирует использование Aspose.Imaging.Cache```csharp [C#]

                                                                // По умолчанию папка кэша установлена в локальный временный каталог пользователя.
                                                                // Вы также можете указать другую папку кэша, отличную от стандартной, следующим образом:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Автоматический режим гибок и эффективен
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Значение по умолчанию равно 0, что означает отсутствие верхнего предела
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 гигабайт
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 гигабайт

                                                                // Не рекомендуется изменять следующее свойство, так как это может значительно повлиять на производительность
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // В любое время вы можете проверить, сколько байт в настоящее время выделено для памяти или диска 
                                                                // кэша, проверив следующие свойства
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Выполните обработку изображения, как показано ниже
                                                                Aspose.Imaging.ImageOptions.GifOptions options = new Aspose.Imaging.ImageOptions.GifOptions();
                                                                options.Palette = new ColorPalette(new Aspose.Imaging.Color[] { Aspose.Imaging.Color.Red, Aspose.Imaging.Color.Blue, Aspose.Imaging.Color.Black, Aspose.Imaging.Color.White });
                                                                options.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);
                                                                using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(options, 100, 100))
                                                                {
                                                                    Aspose.Imaging.Color[] pixels = new Aspose.Imaging.Color[10000];
                                                                    for (int i = 0; i &lt; pixels.Length; i++)
                                                                    {
                                                                        pixels[i] = Aspose.Imaging.Color.White;
                                                                    }

                                                                    image.SavePixels(image.Bounds, pixels);

                                                                    // после выполнения кода выше будет выделено 40000 байт в памяти.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Свойства выделения могут использоваться для проверки, были ли все объекты Aspose.Imaging правильно освобождены.
                                                                // Если вы забыли вызвать dispose для какого-либо объекта, значения кэша будут отличаться от 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

#### Примечания

Значение 0 будет использовать всю доступную память и служит отсутствием верхнего предела.

### <a id="Aspose_Imaging_Cache_MaxMemoryForCache"></a> MaxMemoryForCache

Получает или задает максимальную доступную память для кэша в памяти. Указанное значение - это количество мегабайт.

```csharp
public static int MaxMemoryForCache { get; set; }

Значение свойства

int

Примеры

Этот пример демонстрирует использование Aspose.Imaging.Cache```csharp [C#]

                                                                // По умолчанию папка кэша установлена в локальный временный каталог пользователя.
                                                                // Вы также можете указать другую папку кэша, отличную от стандартной, следующим образом:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Автоматический режим гибок и эффективен
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Значение по умолчанию равно 0, что означает отсутствие верхнего предела
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 гигабайт
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 гигабайт

                                                                // Не рекомендуется изменять следующее свойство, так как это может значительно повлиять на производительность
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // В любое время вы можете проверить, сколько байт в настоящее время выделено для памяти или диска 
                                                                // кэша, проверив следующие свойства
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Выполните обработку изображения, как показано ниже
                                                                Aspose.Imaging.ImageOptions.GifOptions options = new Aspose.Imaging.ImageOptions.GifOptions();
                                                                options.Palette = new ColorPalette(new Aspose.Imaging.Color[] { Aspose.Imaging.Color.Red, Aspose.Imaging.Color.Blue, Aspose.Imaging.Color.Black, Aspose.Imaging.Color.White });
                                                                options.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);
                                                                using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(options, 100, 100))
                                                                {
                                                                    Aspose.Imaging.Color[] pixels = new Aspose.Imaging.Color[10000];
                                                                    for (int i = 0; i &lt; pixels.Length; i++)
                                                                    {
                                                                        pixels[i] = Aspose.Imaging.Color.White;
                                                                    }

                                                                    image.SavePixels(image.Bounds, pixels);

                                                                    // после выполнения кода выше будет выделено 40000 байт в памяти.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Свойства выделения могут использоваться для проверки, были ли все объекты Aspose.Imaging правильно освобождены.
                                                                // Если вы забыли вызвать dispose для какого-либо объекта, значения кэша будут отличаться от 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

#### Примечания

Значение 0 будет использовать всю доступную память и служит отсутствием верхнего предела.

## Методы

### <a id="Aspose_Imaging_Cache_SetDefaults"></a> SetDefaults\(\)

Устанавливает настройки Aspose.Imaging.Cache по умолчанию.

```csharp
public static void SetDefaults()
 Русский