use _lazyImage?

ikkyuland · ikkyuland · commit 4c55ed7f0495 · 2025-08-08T14:31:19.000+07:00
diff --git a/IronSoftware.Drawing/IronSoftware.Drawing.Common/AnyBitmap.cs b/IronSoftware.Drawing/IronSoftware.Drawing.Common/AnyBitmap.cs
@@ -84,7 +84,7 @@ private byte[] Binary
                             using var stream = new MemoryStream();
                             IImageEncoder enc = GetDefaultImageExportEncoder();
 
-                            _lazyImage.Value.First().Save(stream, enc);
+                            _lazyImage?.Value.First().Save(stream, enc);
                             _binary = stream.ToArray();
                             IsDirty = false;
                         }
@@ -127,7 +127,7 @@ public int Width
             {
                 if (!_width.HasValue)
                 {
-                    _width = _lazyImage.Value.First().Width;
+                    _width = _lazyImage?.Value.First().Width;
                 }
                 return _width.Value;
             }
@@ -145,7 +145,7 @@ public int Height
             {
                 if (!_height.HasValue)
                 {
-                    _height = _lazyImage.Value.First().Height;
+                    _height = _lazyImage?.Value.First().Height;
                 }
                 return _height.Value;
             }
@@ -365,16 +365,16 @@ public void ExportStream(
                 IImageEncoder enc = GetDefaultImageExportEncoder(format, lossy);
                 if (enc is TiffEncoder)
                 {
-                    InternalSaveAsMultiPageTiff(_lazyImage.Value, stream);
+                    InternalSaveAsMultiPageTiff(_lazyImage?.Value, stream);
                 }
                 else if (enc is GifEncoder)
                 {
-                    InternalSaveAsMultiPageGif(_lazyImage.Value, stream);
+                    InternalSaveAsMultiPageGif(_lazyImage?.Value, stream);
 
                 }
                 else
                 {
-                    _lazyImage.Value.First().Save(stream, enc);
+                    _lazyImage?.Value.First().Save(stream, enc);
                 }
 
             }
@@ -995,7 +995,7 @@ public int BitsPerPixel
             {
                 if (!_bitsPerPixel.HasValue)
                 {
-                    _bitsPerPixel = _lazyImage.Value.First().PixelType.BitsPerPixel;
+                    _bitsPerPixel = _lazyImage?.Value.First().PixelType.BitsPerPixel;
                 }
                 return _bitsPerPixel.Value;
             }
@@ -1018,13 +1018,13 @@ public int FrameCount
             {
                 if (!_frameCount.HasValue)
                 {
-                    if (_lazyImage.Value.Count() == 1)
+                    if (_lazyImage?.Value.Count() == 1)
                     {
-                        _frameCount = _lazyImage.Value.First().Frames.Count;
+                        _frameCount = _lazyImage?.Value.First().Frames.Count;
                     }
                     else
                     {
-                        _frameCount = _lazyImage.Value.Count();
+                        _frameCount = _lazyImage?.Value.Count();
                     }
                 }
 
@@ -1046,13 +1046,13 @@ public IEnumerable<AnyBitmap> GetAllFrames
         {
             get
             {
-                if (_lazyImage.Value.Count() == 1)
+                if (_lazyImage?.Value.Count() == 1)
                 {
-                    return ImageFrameCollectionToImages(_lazyImage.Value.First().Frames).Select(x => (AnyBitmap)x);
+                    return ImageFrameCollectionToImages(_lazyImage?.Value.First().Frames).Select(x => (AnyBitmap)x);
                 }
                 else
                 {
-                    return _lazyImage.Value.Select(x => (AnyBitmap)x);
+                    return _lazyImage?.Value.Select(x => (AnyBitmap)x);
                 }
             }
         }
@@ -1138,7 +1138,7 @@ public byte[] ExtractAlphaData()
 
             var alpha = new byte[Width * Height];
 
-            switch (_lazyImage.Value.First())
+            switch (_lazyImage?.Value.First())
             {
                 case Image<Rgba32> imageAsFormat:
                     imageAsFormat.ProcessPixelRows(accessor =>
@@ -1464,7 +1464,7 @@ public void SetPixel(int x, int y, Color color)
         /// </remarks>
         public byte[] GetRGBBuffer()
         {
-            var image = _lazyImage.Value.First();
+            var image = _lazyImage?.Value.First();
             int width = image.Width;
             int height = image.Height;
             byte[] rgbBuffer = new byte[width * height * 3]; // 3 bytes per pixel (RGB)
@@ -1650,7 +1650,7 @@ public byte[] GetRGBBuffer()
         /// </remarks>
         public byte[] GetRGBABuffer()
         {
-            var image = _lazyImage.Value.First();
+            var image = _lazyImage?.Value.First();
             int width = image.Width;
             int height = image.Height;
             byte[] rgbBuffer = new byte[width * height * 4]; // 3 bytes per pixel (RGB)
@@ -1887,7 +1887,7 @@ private static Image CastToImageSharp(AnyBitmap bitmap)
                 }
 
                 //if it is loaded or gif/tiff
-                var images = bitmap._lazyImage.Value;
+                var images = bitmap._lazyImage?.Value;
                 if (images.Count() == 1)
                 {
                     //not gif/tiff
@@ -1948,7 +1948,7 @@ private static Image<T> CastToImageSharp<T>(AnyBitmap bitmap) where T :unmanaged
                    
                 }
               
-                var images = bitmap._lazyImage.Value;
+                var images = bitmap._lazyImage?.Value;
                 if (images.Count() == 1)
                 {
                     if (images.First() is Image<T> correctType)
@@ -2597,7 +2597,7 @@ private void CreateNewImageInstance(int width, int height, Color backgroundColor
                 }
                 return [image];
             });
-            var _ = _lazyImage.Value; // force load image
+            var _ = _lazyImage?.Value; // force load image
         }
 
         private void LoadImage(Stream stream, bool preserveOriginalFormat)
@@ -3132,7 +3132,7 @@ private int GetStride(Image source = null)
 
         private IntPtr GetFirstPixelData()
         {
-            var image = _lazyImage.Value.First();
+            var image = _lazyImage?.Value.First();
 
             if(image is not Image<Rgba32>)
             {
@@ -3169,7 +3169,7 @@ private static void ConvertRGBAtoBGRA(byte[] data, int width, int height, int sa
 
         private Color GetPixelColor(int x, int y)
         {
-            switch (_lazyImage.Value.First())
+            switch (_lazyImage?.Value.First())
             {
                 case Image<Rgba32> imageAsFormat:
                     return imageAsFormat[x, y];
@@ -3195,7 +3195,7 @@ private Color GetPixelColor(int x, int y)
 
                     //CloneAs() is expensive!
                     //Can throw out of memory exception, when this fucntion get called too much
-                    using (Image<Rgb24> converted = _lazyImage.Value.First().CloneAs<Rgb24>())
+                    using (Image<Rgb24> converted = _lazyImage?.Value.First().CloneAs<Rgb24>())
                     {
                         return converted[x, y];
                     }
@@ -3204,7 +3204,7 @@ private Color GetPixelColor(int x, int y)
 
         private void SetPixelColor(int x, int y, Color color)
         {
-            switch (_lazyImage.Value.First())
+            switch (_lazyImage?.Value.First())
             {
                 case Image<Rgba32> imageAsFormat:
                     imageAsFormat[x, y] = color;
@@ -3231,7 +3231,7 @@ private void SetPixelColor(int x, int y, Color color)
                     imageAsFormat[x, y] = color;
                     break;
                 default:
-                    (_lazyImage.Value.First() as Image<Rgba32>)[x, y] = color;
+                    (_lazyImage?.Value.First() as Image<Rgba32>)[x, y] = color;
                     break;
             }
             IsDirty = true;
@@ -3261,7 +3261,7 @@ private void LoadAndResizeImage(AnyBitmap original, int width, int height)
             });
 
             //force _lazyImage to load in this case
-            var _ = _lazyImage.Value;
+            var _ = _lazyImage?.Value;
         }
 
         private IImageEncoder GetDefaultImageExportEncoder(ImageFormat format = ImageFormat.Default, int lossy = 100)
@@ -3484,7 +3484,7 @@ private static void InternalSaveAsMultiPageGif(IEnumerable<Image> images, Stream
         /// <returns>true if images is loaded (decoded) into the memory</returns>
         public bool IsImageLoaded()
         {
-            return _lazyImage.IsValueCreated;
+            return _lazyImage?.IsValueCreated;
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ private byte[] Binary`
`84`	`84`	`using var stream = new MemoryStream();`
`85`	`85`	`IImageEncoder enc = GetDefaultImageExportEncoder();`
`86`	`86`
`87`		`- _lazyImage.Value.First().Save(stream, enc);`
	`87`	`+ _lazyImage?.Value.First().Save(stream, enc);`
`88`	`88`	`_binary = stream.ToArray();`
`89`	`89`	`IsDirty = false;`
`90`	`90`	`}`
`@@ -127,7 +127,7 @@ public int Width`
`127`	`127`	`{`
`128`	`128`	`if (!_width.HasValue)`
`129`	`129`	`{`
`130`		`- _width = _lazyImage.Value.First().Width;`
	`130`	`+ _width = _lazyImage?.Value.First().Width;`
`131`	`131`	`}`
`132`	`132`	`return _width.Value;`
`133`	`133`	`}`
`@@ -145,7 +145,7 @@ public int Height`
`145`	`145`	`{`
`146`	`146`	`if (!_height.HasValue)`
`147`	`147`	`{`
`148`		`- _height = _lazyImage.Value.First().Height;`
	`148`	`+ _height = _lazyImage?.Value.First().Height;`
`149`	`149`	`}`
`150`	`150`	`return _height.Value;`
`151`	`151`	`}`
`@@ -365,16 +365,16 @@ public void ExportStream(`
`365`	`365`	`IImageEncoder enc = GetDefaultImageExportEncoder(format, lossy);`
`366`	`366`	`if (enc is TiffEncoder)`
`367`	`367`	`{`
`368`		`- InternalSaveAsMultiPageTiff(_lazyImage.Value, stream);`
	`368`	`+ InternalSaveAsMultiPageTiff(_lazyImage?.Value, stream);`
`369`	`369`	`}`
`370`	`370`	`else if (enc is GifEncoder)`
`371`	`371`	`{`
`372`		`- InternalSaveAsMultiPageGif(_lazyImage.Value, stream);`
	`372`	`+ InternalSaveAsMultiPageGif(_lazyImage?.Value, stream);`
`373`	`373`
`374`	`374`	`}`
`375`	`375`	`else`
`376`	`376`	`{`
`377`		`- _lazyImage.Value.First().Save(stream, enc);`
	`377`	`+ _lazyImage?.Value.First().Save(stream, enc);`
`378`	`378`	`}`
`379`	`379`
`380`	`380`	`}`
`@@ -995,7 +995,7 @@ public int BitsPerPixel`
`995`	`995`	`{`
`996`	`996`	`if (!_bitsPerPixel.HasValue)`
`997`	`997`	`{`
`998`		`- _bitsPerPixel = _lazyImage.Value.First().PixelType.BitsPerPixel;`
	`998`	`+ _bitsPerPixel = _lazyImage?.Value.First().PixelType.BitsPerPixel;`
`999`	`999`	`}`
`1000`	`1000`	`return _bitsPerPixel.Value;`
`1001`	`1001`	`}`
`@@ -1018,13 +1018,13 @@ public int FrameCount`
`1018`	`1018`	`{`
`1019`	`1019`	`if (!_frameCount.HasValue)`
`1020`	`1020`	`{`
`1021`		`- if (_lazyImage.Value.Count() == 1)`
	`1021`	`+ if (_lazyImage?.Value.Count() == 1)`
`1022`	`1022`	`{`
`1023`		`- _frameCount = _lazyImage.Value.First().Frames.Count;`
	`1023`	`+ _frameCount = _lazyImage?.Value.First().Frames.Count;`
`1024`	`1024`	`}`
`1025`	`1025`	`else`
`1026`	`1026`	`{`
`1027`		`- _frameCount = _lazyImage.Value.Count();`
	`1027`	`+ _frameCount = _lazyImage?.Value.Count();`
`1028`	`1028`	`}`
`1029`	`1029`	`}`
`1030`	`1030`
`@@ -1046,13 +1046,13 @@ public IEnumerable<AnyBitmap> GetAllFrames`
`1046`	`1046`	`{`
`1047`	`1047`	`get`
`1048`	`1048`	`{`
`1049`		`- if (_lazyImage.Value.Count() == 1)`
	`1049`	`+ if (_lazyImage?.Value.Count() == 1)`
`1050`	`1050`	`{`
`1051`		`- return ImageFrameCollectionToImages(_lazyImage.Value.First().Frames).Select(x => (AnyBitmap)x);`
	`1051`	`+ return ImageFrameCollectionToImages(_lazyImage?.Value.First().Frames).Select(x => (AnyBitmap)x);`
`1052`	`1052`	`}`
`1053`	`1053`	`else`
`1054`	`1054`	`{`
`1055`		`- return _lazyImage.Value.Select(x => (AnyBitmap)x);`
	`1055`	`+ return _lazyImage?.Value.Select(x => (AnyBitmap)x);`
`1056`	`1056`	`}`
`1057`	`1057`	`}`
`1058`	`1058`	`}`
`@@ -1138,7 +1138,7 @@ public byte[] ExtractAlphaData()`
`1138`	`1138`
`1139`	`1139`	`var alpha = new byte[Width * Height];`
`1140`	`1140`
`1141`		`- switch (_lazyImage.Value.First())`
	`1141`	`+ switch (_lazyImage?.Value.First())`
`1142`	`1142`	`{`
`1143`	`1143`	`case Image<Rgba32> imageAsFormat:`
`1144`	`1144`	`imageAsFormat.ProcessPixelRows(accessor =>`
`@@ -1464,7 +1464,7 @@ public void SetPixel(int x, int y, Color color)`
`1464`	`1464`	`/// </remarks>`
`1465`	`1465`	`public byte[] GetRGBBuffer()`
`1466`	`1466`	`{`
`1467`		`- var image = _lazyImage.Value.First();`
	`1467`	`+ var image = _lazyImage?.Value.First();`
`1468`	`1468`	`int width = image.Width;`
`1469`	`1469`	`int height = image.Height;`
`1470`	`1470`	`byte[] rgbBuffer = new byte[width * height * 3]; // 3 bytes per pixel (RGB)`
`@@ -1650,7 +1650,7 @@ public byte[] GetRGBBuffer()`
`1650`	`1650`	`/// </remarks>`
`1651`	`1651`	`public byte[] GetRGBABuffer()`
`1652`	`1652`	`{`
`1653`		`- var image = _lazyImage.Value.First();`
	`1653`	`+ var image = _lazyImage?.Value.First();`
`1654`	`1654`	`int width = image.Width;`
`1655`	`1655`	`int height = image.Height;`
`1656`	`1656`	`byte[] rgbBuffer = new byte[width * height * 4]; // 3 bytes per pixel (RGB)`
`@@ -1887,7 +1887,7 @@ private static Image CastToImageSharp(AnyBitmap bitmap)`
`1887`	`1887`	`}`
`1888`	`1888`
`1889`	`1889`	`//if it is loaded or gif/tiff`
`1890`		`- var images = bitmap._lazyImage.Value;`
	`1890`	`+ var images = bitmap._lazyImage?.Value;`
`1891`	`1891`	`if (images.Count() == 1)`
`1892`	`1892`	`{`
`1893`	`1893`	`//not gif/tiff`
`@@ -1948,7 +1948,7 @@ private static Image<T> CastToImageSharp<T>(AnyBitmap bitmap) where T :unmanaged`
`1948`	`1948`
`1949`	`1949`	`}`
`1950`	`1950`
`1951`		`- var images = bitmap._lazyImage.Value;`
	`1951`	`+ var images = bitmap._lazyImage?.Value;`
`1952`	`1952`	`if (images.Count() == 1)`
`1953`	`1953`	`{`
`1954`	`1954`	`if (images.First() is Image<T> correctType)`
`@@ -2597,7 +2597,7 @@ private void CreateNewImageInstance(int width, int height, Color backgroundColor`
`2597`	`2597`	`}`
`2598`	`2598`	`return [image];`
`2599`	`2599`	`});`
`2600`		`- var _ = _lazyImage.Value; // force load image`
	`2600`	`+ var _ = _lazyImage?.Value; // force load image`
`2601`	`2601`	`}`
`2602`	`2602`
`2603`	`2603`	`private void LoadImage(Stream stream, bool preserveOriginalFormat)`
`@@ -3132,7 +3132,7 @@ private int GetStride(Image source = null)`
`3132`	`3132`
`3133`	`3133`	`private IntPtr GetFirstPixelData()`
`3134`	`3134`	`{`
`3135`		`- var image = _lazyImage.Value.First();`
	`3135`	`+ var image = _lazyImage?.Value.First();`
`3136`	`3136`
`3137`	`3137`	`if(image is not Image<Rgba32>)`
`3138`	`3138`	`{`
`@@ -3169,7 +3169,7 @@ private static void ConvertRGBAtoBGRA(byte[] data, int width, int height, int sa`
`3169`	`3169`
`3170`	`3170`	`private Color GetPixelColor(int x, int y)`
`3171`	`3171`	`{`
`3172`		`- switch (_lazyImage.Value.First())`
	`3172`	`+ switch (_lazyImage?.Value.First())`
`3173`	`3173`	`{`
`3174`	`3174`	`case Image<Rgba32> imageAsFormat:`
`3175`	`3175`	`return imageAsFormat[x, y];`
`@@ -3195,7 +3195,7 @@ private Color GetPixelColor(int x, int y)`
`3195`	`3195`
`3196`	`3196`	`//CloneAs() is expensive!`
`3197`	`3197`	`//Can throw out of memory exception, when this fucntion get called too much`
`3198`		`- using (Image<Rgb24> converted = _lazyImage.Value.First().CloneAs<Rgb24>())`
	`3198`	`+ using (Image<Rgb24> converted = _lazyImage?.Value.First().CloneAs<Rgb24>())`
`3199`	`3199`	`{`
`3200`	`3200`	`return converted[x, y];`
`3201`	`3201`	`}`
`@@ -3204,7 +3204,7 @@ private Color GetPixelColor(int x, int y)`
`3204`	`3204`
`3205`	`3205`	`private void SetPixelColor(int x, int y, Color color)`
`3206`	`3206`	`{`
`3207`		`- switch (_lazyImage.Value.First())`
	`3207`	`+ switch (_lazyImage?.Value.First())`
`3208`	`3208`	`{`
`3209`	`3209`	`case Image<Rgba32> imageAsFormat:`
`3210`	`3210`	`imageAsFormat[x, y] = color;`
`@@ -3231,7 +3231,7 @@ private void SetPixelColor(int x, int y, Color color)`
`3231`	`3231`	`imageAsFormat[x, y] = color;`
`3232`	`3232`	`break;`
`3233`	`3233`	`default:`
`3234`		`- (_lazyImage.Value.First() as Image<Rgba32>)[x, y] = color;`
	`3234`	`+ (_lazyImage?.Value.First() as Image<Rgba32>)[x, y] = color;`
`3235`	`3235`	`break;`
`3236`	`3236`	`}`
`3237`	`3237`	`IsDirty = true;`
`@@ -3261,7 +3261,7 @@ private void LoadAndResizeImage(AnyBitmap original, int width, int height)`
`3261`	`3261`	`});`
`3262`	`3262`
`3263`	`3263`	`//force _lazyImage to load in this case`
`3264`		`- var _ = _lazyImage.Value;`
	`3264`	`+ var _ = _lazyImage?.Value;`
`3265`	`3265`	`}`
`3266`	`3266`
`3267`	`3267`	`private IImageEncoder GetDefaultImageExportEncoder(ImageFormat format = ImageFormat.Default, int lossy = 100)`
`@@ -3484,7 +3484,7 @@ private static void InternalSaveAsMultiPageGif(IEnumerable<Image> images, Stream`
`3484`	`3484`	`/// <returns>true if images is loaded (decoded) into the memory</returns>`
`3485`	`3485`	`public bool IsImageLoaded()`
`3486`	`3486`	`{`
`3487`		`- return _lazyImage.IsValueCreated;`
	`3487`	`+ return _lazyImage?.IsValueCreated;`
`3488`	`3488`	`}`
`3489`	`3489`	`}`
`3490`	`3490`	`}`