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()
 Українська