Class Cache

Class Cache

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

Berisi pengaturan cache.

public static class Cache

Pewarisan

objectCache

Anggota yang Diperoleh

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

Contoh

Contoh ini menunjukkan penggunaan Aspose.Imaging.Cache```csharp [C#]

                                                                // Secara default, folder cache diatur ke direktori sementara lokal pengguna.
                                                                // Anda juga dapat menentukan folder cache lain selain default seperti berikut:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Mode otomatis fleksibel dan efisien
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Nilai default adalah 0, yang berarti tidak ada batas atas
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                // Tidak disarankan untuk mengubah properti berikut karena dapat sangat mempengaruhi kinerja
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // Kapan saja Anda dapat memeriksa berapa banyak byte yang saat ini dialokasikan untuk memori atau disk 
                                                                // cache dengan memeriksa properti berikut
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Lakukan beberapa pemrosesan gambar seperti di bawah ini
                                                                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);

                                                                    // setelah mengeksekusi kode di atas, akan ada 40000 byte yang dialokasikan dalam memori.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Properti alokasi dapat digunakan untuk memeriksa apakah semua objek Aspose.Imaging telah dibersihkan dengan benar.
                                                                // Jika Anda lupa memanggil dispose pada beberapa objek, nilai cache akan berbeda dari 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

## Properti

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

Mengambil jumlah byte disk yang dialokasikan.

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

Nilai Properti

long

Contoh

Contoh ini menunjukkan penggunaan Aspose.Imaging.Cache```csharp [C#]

                                                                // Secara default, folder cache diatur ke direktori sementara lokal pengguna.
                                                                // Anda juga dapat menentukan folder cache lain selain default seperti berikut:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Mode otomatis fleksibel dan efisien
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Nilai default adalah 0, yang berarti tidak ada batas atas
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                // Tidak disarankan untuk mengubah properti berikut karena dapat sangat mempengaruhi kinerja
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // Kapan saja Anda dapat memeriksa berapa banyak byte yang saat ini dialokasikan untuk memori atau disk 
                                                                // cache dengan memeriksa properti berikut
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Lakukan beberapa pemrosesan gambar seperti di bawah ini
                                                                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);

                                                                    // setelah mengeksekusi kode di atas, akan ada 40000 byte yang dialokasikan dalam memori.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Properti alokasi dapat digunakan untuk memeriksa apakah semua objek Aspose.Imaging telah dibersihkan dengan benar.
                                                                // Jika Anda lupa memanggil dispose pada beberapa objek, nilai cache akan berbeda dari 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

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

Mengambil jumlah byte yang dialokasikan dalam memori.

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

Nilai Properti

long

Contoh

Contoh ini menunjukkan penggunaan Aspose.Imaging.Cache```csharp [C#]

                                                                // Secara default, folder cache diatur ke direktori sementara lokal pengguna.
                                                                // Anda juga dapat menentukan folder cache lain selain default seperti berikut:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Mode otomatis fleksibel dan efisien
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Nilai default adalah 0, yang berarti tidak ada batas atas
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                // Tidak disarankan untuk mengubah properti berikut karena dapat sangat mempengaruhi kinerja
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // Kapan saja Anda dapat memeriksa berapa banyak byte yang saat ini dialokasikan untuk memori atau disk 
                                                                // cache dengan memeriksa properti berikut
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Lakukan beberapa pemrosesan gambar seperti di bawah ini
                                                                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);

                                                                    // setelah mengeksekusi kode di atas, akan ada 40000 byte yang dialokasikan dalam memori.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Properti alokasi dapat digunakan untuk memeriksa apakah semua objek Aspose.Imaging telah dibersihkan dengan benar.
                                                                // Jika Anda lupa memanggil dispose pada beberapa objek, nilai cache akan berbeda dari 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

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

Mengambil atau mengatur folder cache.

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

Nilai Properti

string

CacheType

Mengambil atau mengatur skema cache yang digunakan.

public static CacheType CacheType { get; set; }

Nilai Properti

CacheType

Contoh

Contoh ini menunjukkan penggunaan Aspose.Imaging.Cache```csharp [C#]

                                                                // Secara default, folder cache diatur ke direktori sementara lokal pengguna.
                                                                // Anda juga dapat menentukan folder cache lain selain default seperti berikut:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Mode otomatis fleksibel dan efisien
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Nilai default adalah 0, yang berarti tidak ada batas atas
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                // Tidak disarankan untuk mengubah properti berikut karena dapat sangat mempengaruhi kinerja
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // Kapan saja Anda dapat memeriksa berapa banyak byte yang saat ini dialokasikan untuk memori atau disk 
                                                                // cache dengan memeriksa properti berikut
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Lakukan beberapa pemrosesan gambar seperti di bawah ini
                                                                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);

                                                                    // setelah mengeksekusi kode di atas, akan ada 40000 byte yang dialokasikan dalam memori.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Properti alokasi dapat digunakan untuk memeriksa apakah semua objek Aspose.Imaging telah dibersihkan dengan benar.
                                                                // Jika Anda lupa memanggil dispose pada beberapa objek, nilai cache akan berbeda dari 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

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

Mengambil atau mengatur nilai yang menunjukkan apakah realokasi harus tepat atau tidak. Jika realokasi tidak tepat, kinerja harus lebih tinggi.

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

Nilai Properti

bool

Contoh

Contoh ini menunjukkan penggunaan Aspose.Imaging.Cache```csharp [C#]

                                                                // Secara default, folder cache diatur ke direktori sementara lokal pengguna.
                                                                // Anda juga dapat menentukan folder cache lain selain default seperti berikut:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Mode otomatis fleksibel dan efisien
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Nilai default adalah 0, yang berarti tidak ada batas atas
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                // Tidak disarankan untuk mengubah properti berikut karena dapat sangat mempengaruhi kinerja
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // Kapan saja Anda dapat memeriksa berapa banyak byte yang saat ini dialokasikan untuk memori atau disk 
                                                                // cache dengan memeriksa properti berikut
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Lakukan beberapa pemrosesan gambar seperti di bawah ini
                                                                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);

                                                                    // setelah mengeksekusi kode di atas, akan ada 40000 byte yang dialokasikan dalam memori.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Properti alokasi dapat digunakan untuk memeriksa apakah semua objek Aspose.Imaging telah dibersihkan dengan benar.
                                                                // Jika Anda lupa memanggil dispose pada beberapa objek, nilai cache akan berbeda dari 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

#### Catatan

Realokasi yang tepat akan melakukan realokasi tambahan memori hanya hingga batas atas yang ditentukan.  
Saat melewati batas atas untuk memori dalam memori selama realokasi, data yang di-cache akan disalin ke disk jika memungkinkan.  
Saat melewati batas atas untuk memori disk selama realokasi, pengecualian yang sesuai akan dilemparkan.  
Kinerja harus lebih tinggi jika opsi ini dimatikan karena tidak ada penyalinan tambahan yang akan dilakukan jika memungkinkan,  
namun ini juga dapat menyebabkan melewati batas atas yang ditentukan untuk memori atau disk.

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

Mengambil atau mengatur ruang disk maksimum yang tersedia untuk cache. Nilai yang ditentukan adalah jumlah megabyte.

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

Nilai Properti

int

Contoh

Contoh ini menunjukkan penggunaan Aspose.Imaging.Cache```csharp [C#]

                                                                // Secara default, folder cache diatur ke direktori sementara lokal pengguna.
                                                                // Anda juga dapat menentukan folder cache lain selain default seperti berikut:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Mode otomatis fleksibel dan efisien
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Nilai default adalah 0, yang berarti tidak ada batas atas
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                // Tidak disarankan untuk mengubah properti berikut karena dapat sangat mempengaruhi kinerja
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // Kapan saja Anda dapat memeriksa berapa banyak byte yang saat ini dialokasikan untuk memori atau disk 
                                                                // cache dengan memeriksa properti berikut
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Lakukan beberapa pemrosesan gambar seperti di bawah ini
                                                                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);

                                                                    // setelah mengeksekusi kode di atas, akan ada 40000 byte yang dialokasikan dalam memori.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Properti alokasi dapat digunakan untuk memeriksa apakah semua objek Aspose.Imaging telah dibersihkan dengan benar.
                                                                // Jika Anda lupa memanggil dispose pada beberapa objek, nilai cache akan berbeda dari 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

#### Catatan

Nilai 0 akan menggunakan semua memori yang tersedia dan berfungsi sebagai tidak ada batas atas.

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

Mengambil atau mengatur memori maksimum yang tersedia untuk cache dalam memori. Nilai yang ditentukan adalah jumlah megabyte.

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

Nilai Properti

int

Contoh

Contoh ini menunjukkan penggunaan Aspose.Imaging.Cache```csharp [C#]

                                                                // Secara default, folder cache diatur ke direktori sementara lokal pengguna.
                                                                // Anda juga dapat menentukan folder cache lain selain default seperti berikut:
                                                                // Cache.CacheFolder = @"D:\\MyTemp";

                                                                // Mode otomatis fleksibel dan efisien
                                                                Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                // Nilai default adalah 0, yang berarti tidak ada batas atas
                                                                Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                // Tidak disarankan untuk mengubah properti berikut karena dapat sangat mempengaruhi kinerja
                                                                Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                // Kapan saja Anda dapat memeriksa berapa banyak byte yang saat ini dialokasikan untuk memori atau disk 
                                                                // cache dengan memeriksa properti berikut
                                                                long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                // Lakukan beberapa pemrosesan gambar seperti di bawah ini
                                                                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);

                                                                    // setelah mengeksekusi kode di atas, akan ada 40000 byte yang dialokasikan dalam memori.
                                                                    long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                }

                                                                // Properti alokasi dapat digunakan untuk memeriksa apakah semua objek Aspose.Imaging telah dibersihkan dengan benar.
                                                                // Jika Anda lupa memanggil dispose pada beberapa objek, nilai cache akan berbeda dari 0.            
                                                                l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

#### Catatan

Nilai 0 akan menggunakan semua memori yang tersedia dan berfungsi sebagai tidak ada batas atas.

## Metode

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

Mengatur pengaturan Aspose.Imaging.Cache ke default.

```csharp
public static void SetDefaults()
 Indonesia