Class Cache

Class Cache

A név: Aspose.Imaging Összefoglaló: Aspose.Imaging.dll (25.4.0)

Tartalmazza a cache beállításokat.

public static class Cache

Inheritance

object Cache

Örökletes tagok

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

Examples

Ez a példa megmutatja a Aspose.Imaging.Cache használatát

// By default the cache folder is set to user's local temp directory.
                                                                    // You can also specify another cache folder than default like the following:
                                                                    // Cache.CacheFolder = @"D:\\MyTemp";

                                                                    // Auto mode is flexible and efficient
                                                                    Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                    // Default value is 0, which means there is no upper limit
                                                                    Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                    Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                    // It is not recommended to change the following property as it may greatly affect the performance
                                                                    Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                    // At any time you may check how many bytes currently allocated for memory or disk 
                                                                    // cache by examining the following properties
                                                                    long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                    // Do some image processing as below
                                                                    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);

                                                                        // after executing the code above there will be allocated 40000 bytes in-memory.
                                                                        long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                        long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                    }

                                                                    // The allocation properties may be used to check whether all Aspose.Imaging objects were properly disposed.
                                                                    // In case you've forgot to call dispose on some object the cache values will be different than 0.            
                                                                    l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

Properties

AllocatedDiskBytesCount

Megkapja az elosztott lemez bajtok számát.

public static long AllocatedDiskBytesCount { get; }

ingatlan értéke

long

Examples

Ez a példa megmutatja a Aspose.Imaging.Cache használatát

// By default the cache folder is set to user's local temp directory.
                                                                    // You can also specify another cache folder than default like the following:
                                                                    // Cache.CacheFolder = @"D:\\MyTemp";

                                                                    // Auto mode is flexible and efficient
                                                                    Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                    // Default value is 0, which means there is no upper limit
                                                                    Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                    Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                    // It is not recommended to change the following property as it may greatly affect the performance
                                                                    Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                    // At any time you may check how many bytes currently allocated for memory or disk 
                                                                    // cache by examining the following properties
                                                                    long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                    // Do some image processing as below
                                                                    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);

                                                                        // after executing the code above there will be allocated 40000 bytes in-memory.
                                                                        long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                        long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                    }

                                                                    // The allocation properties may be used to check whether all Aspose.Imaging objects were properly disposed.
                                                                    // In case you've forgot to call dispose on some object the cache values will be different than 0.            
                                                                    l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

AllocatedMemoryBytesCount

Megkapja az elosztott in-memory bajtok számát.

public static long AllocatedMemoryBytesCount { get; }

ingatlan értéke

long

Examples

Ez a példa megmutatja a Aspose.Imaging.Cache használatát

// By default the cache folder is set to user's local temp directory.
                                                                    // You can also specify another cache folder than default like the following:
                                                                    // Cache.CacheFolder = @"D:\\MyTemp";

                                                                    // Auto mode is flexible and efficient
                                                                    Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                    // Default value is 0, which means there is no upper limit
                                                                    Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                    Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                    // It is not recommended to change the following property as it may greatly affect the performance
                                                                    Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                    // At any time you may check how many bytes currently allocated for memory or disk 
                                                                    // cache by examining the following properties
                                                                    long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                    // Do some image processing as below
                                                                    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);

                                                                        // after executing the code above there will be allocated 40000 bytes in-memory.
                                                                        long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                        long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                    }

                                                                    // The allocation properties may be used to check whether all Aspose.Imaging objects were properly disposed.
                                                                    // In case you've forgot to call dispose on some object the cache values will be different than 0.            
                                                                    l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

CacheFolder

Megkapja vagy beállítja a cache mappát.

public static string CacheFolder { get; set; }

ingatlan értéke

string

CacheType

Megkapja vagy beállítja a használt cache rendszert.

public static CacheType CacheType { get; set; }

ingatlan értéke

CacheType

Examples

Ez a példa megmutatja a Aspose.Imaging.Cache használatát

// By default the cache folder is set to user's local temp directory.
                                                                    // You can also specify another cache folder than default like the following:
                                                                    // Cache.CacheFolder = @"D:\\MyTemp";

                                                                    // Auto mode is flexible and efficient
                                                                    Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                    // Default value is 0, which means there is no upper limit
                                                                    Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                    Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                    // It is not recommended to change the following property as it may greatly affect the performance
                                                                    Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                    // At any time you may check how many bytes currently allocated for memory or disk 
                                                                    // cache by examining the following properties
                                                                    long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                    // Do some image processing as below
                                                                    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);

                                                                        // after executing the code above there will be allocated 40000 bytes in-memory.
                                                                        long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                        long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                    }

                                                                    // The allocation properties may be used to check whether all Aspose.Imaging objects were properly disposed.
                                                                    // In case you've forgot to call dispose on some object the cache values will be different than 0.            
                                                                    l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

ExactReallocateOnly

Megkapja vagy beállítja azt a értéket, amely azt jelzi, hogy az újbóli elosztásnak pontosnak kell lennie, vagy sem. Ha az újbóli elosztás nem pontos, a teljesítménynek magasabbnak kell lennie.

public static bool ExactReallocateOnly { get; set; }

ingatlan értéke

bool

Examples

Ez a példa megmutatja a Aspose.Imaging.Cache használatát

// By default the cache folder is set to user's local temp directory.
                                                                    // You can also specify another cache folder than default like the following:
                                                                    // Cache.CacheFolder = @"D:\\MyTemp";

                                                                    // Auto mode is flexible and efficient
                                                                    Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                    // Default value is 0, which means there is no upper limit
                                                                    Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                    Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                    // It is not recommended to change the following property as it may greatly affect the performance
                                                                    Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                    // At any time you may check how many bytes currently allocated for memory or disk 
                                                                    // cache by examining the following properties
                                                                    long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                    // Do some image processing as below
                                                                    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);

                                                                        // after executing the code above there will be allocated 40000 bytes in-memory.
                                                                        long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                        long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                    }

                                                                    // The allocation properties may be used to check whether all Aspose.Imaging objects were properly disposed.
                                                                    // In case you've forgot to call dispose on some object the cache values will be different than 0.            
                                                                    l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

Remarks

A pontos újbóli elosztás a további memória újbóli elosztását csak a meghatározott felső határig végzi.A memória felső határértékének átlépésekor az újraosztás során a titkosított adatokat a lehető legfeljebb a lemezre másolják.Amikor az elosztás során a lemez memóriájának felső határértékét meghaladja, a megfelelő kivételt eldobják.A teljesítménynek magasabbnak kell lennie, ha ezt az opciót kikapcsolják, mivel amennyiben lehetséges, nincs további másolás.Ez azonban a memóriára vagy a lemezre meghatározott felső határértékek átlépéséhez is vezethet.

MaxDiskSpaceForCache

Megkapja vagy beállítja a maximális rendelkezésre álló lemezterületet a cache-hez. A meghatározott érték megabyte számítás.

public static int MaxDiskSpaceForCache { get; set; }

ingatlan értéke

int

Examples

Ez a példa megmutatja a Aspose.Imaging.Cache használatát

// By default the cache folder is set to user's local temp directory.
                                                                    // You can also specify another cache folder than default like the following:
                                                                    // Cache.CacheFolder = @"D:\\MyTemp";

                                                                    // Auto mode is flexible and efficient
                                                                    Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                    // Default value is 0, which means there is no upper limit
                                                                    Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                    Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                    // It is not recommended to change the following property as it may greatly affect the performance
                                                                    Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                    // At any time you may check how many bytes currently allocated for memory or disk 
                                                                    // cache by examining the following properties
                                                                    long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                    // Do some image processing as below
                                                                    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);

                                                                        // after executing the code above there will be allocated 40000 bytes in-memory.
                                                                        long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                        long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                    }

                                                                    // The allocation properties may be used to check whether all Aspose.Imaging objects were properly disposed.
                                                                    // In case you've forgot to call dispose on some object the cache values will be different than 0.            
                                                                    l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

Remarks

A 0 értéke az összes rendelkezésre álló memóriát fogyasztja, és nem szolgál felső határként.

MaxMemoryForCache

Megkapja vagy beállítja a maximális rendelkezésre álló memóriát a cache memóriájában.

public static int MaxMemoryForCache { get; set; }

ingatlan értéke

int

Examples

Ez a példa megmutatja a Aspose.Imaging.Cache használatát

// By default the cache folder is set to user's local temp directory.
                                                                    // You can also specify another cache folder than default like the following:
                                                                    // Cache.CacheFolder = @"D:\\MyTemp";

                                                                    // Auto mode is flexible and efficient
                                                                    Aspose.Imaging.Cache.CacheType = Aspose.Imaging.CacheType.Auto;

                                                                    // Default value is 0, which means there is no upper limit
                                                                    Aspose.Imaging.Cache.MaxDiskSpaceForCache = 1073741824; // 1 gigabyte
                                                                    Aspose.Imaging.Cache.MaxMemoryForCache = 1073741824; // 1 gigabyte

                                                                    // It is not recommended to change the following property as it may greatly affect the performance
                                                                    Aspose.Imaging.Cache.ExactReallocateOnly = false;

                                                                    // At any time you may check how many bytes currently allocated for memory or disk 
                                                                    // cache by examining the following properties
                                                                    long l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    long l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

                                                                    // Do some image processing as below
                                                                    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);

                                                                        // after executing the code above there will be allocated 40000 bytes in-memory.
                                                                        long diskBytes = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                        long memoryBytes = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;
                                                                    }

                                                                    // The allocation properties may be used to check whether all Aspose.Imaging objects were properly disposed.
                                                                    // In case you've forgot to call dispose on some object the cache values will be different than 0.            
                                                                    l1 = Aspose.Imaging.Cache.AllocatedDiskBytesCount;
                                                                    l2 = Aspose.Imaging.Cache.AllocatedMemoryBytesCount;

Remarks

A 0 értéke az összes rendelkezésre álló memóriát fogyasztja, és nem szolgál felső határként.

Methods

SetDefaults()

Állítsa be a Aspose.Imaging.Cache beállításokat az alapértelmezettre.

public static void SetDefaults()
 Magyar