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()
 中文