The reason can be that a file with the new Database name already exist on the filesystem. We encountered this when we renamed Database X to X_Old, and tried to copy database Y to X. This cannot be done, because database X_Old is still associated with the filename X.

Either delete the conflicting database, or rename the file on the file system.

Remember allways to add CacheMode=”BitmapCache” to you Image for performance

XAML:

<Image HorizontalAlignment="Left" Name="photo" Stretch="Uniform" VerticalAlignment="Top" Source="Image.png" CacheMode="BitmapCache">
<Image.RenderTransform>
<CompositeTransform x:Name="ImageTransformation" ScaleX="1" ScaleY="1" />
</Image.RenderTransform>
<toolkit:GestureService.GestureListener>
<toolkit:GestureListener PinchStarted="GestureListener_PinchStarted" PinchDelta="OnPinchDelta" DragDelta="Image_DragDelta" />
</toolkit:GestureService.GestureListener>
</Image>

C# Codebehind:

private Point Center;
private double InitialScale;

private void GestureListener_PinchStarted(object sender, PinchStartedGestureEventArgs e)
{
// Store the initial rotation angle and scaling
InitialScale = ImageTransformation.ScaleX;
// Calculate the center for the zooming
Point firstTouch = e.GetPosition(Image_LargeImage, 0);
Point secondTouch = e.GetPosition(Image_LargeImage, 1);

Center = new Point(firstTouch.X + (secondTouch.X - firstTouch.X) / 2.0, firstTouch.Y + (secondTouch.Y - firstTouch.Y) / 2.0);
}

private void OnPinchDelta(object sender, PinchGestureEventArgs e)
{
// If its less that the original  size or more than 4x then don’t apply
if (InitialScale * e.DistanceRatio > 4 || (InitialScale != 1 && e.DistanceRatio == 1) || InitialScale * e.DistanceRatio < 1)
return;

// If its original size then center it back
if (e.DistanceRatio <= 1.08)
{
ImageTransformation.CenterY = 0;
ImageTransformation.CenterY = 0;
ImageTransformation.TranslateX = 0;
ImageTransformation.TranslateY = 0;
}

ImageTransformation.CenterX = Center.X;
ImageTransformation.CenterY = Center.Y;

// Update the rotation and scaling
if (this.Orientation == PageOrientation.Landscape)
{
// When in landscape we need to zoom faster, if not it looks choppy
ImageTransformation.ScaleX = InitialScale * (1 + (e.DistanceRatio - 1) * 2);
}
else
{
ImageTransformation.ScaleX = InitialScale * e.DistanceRatio;
}
ImageTransformation.ScaleY = ImageTransformation.ScaleX;
}

private void Image_DragDelta(object sender, DragDeltaGestureEventArgs e)
{
// if is not touch enabled or the scale is different than 1 then don’t allow moving
if (ImageTransformation.ScaleX <= 1.1)
return;

double centerX = ImageTransformation.CenterX;
double centerY = ImageTransformation.CenterY;
double translateX = ImageTransformation.TranslateX;
double translateY = ImageTransformation.TranslateY;
double scale = ImageTransformation.ScaleX;
double width = Image_LargeImage.ActualWidth;
double height = Image_LargeImage.ActualHeight;

// Verify limits to not allow the image to get out of area
if (centerX - scale * centerX + translateX + e.HorizontalChange < 0 && centerX + scale * (width - centerX) + translateX + e.HorizontalChange > width)
{
ImageTransformation.TranslateX += e.HorizontalChange;
}

if (centerY - scale * centerY + translateY + e.VerticalChange < 0 && centerY + scale * (height - centerY) + translateY + e.VerticalChange > height)
{
ImageTransformation.TranslateY += e.VerticalChange;
}

return;
}

http://www.developerfusion.com/tools/convert/vb-to-csharp/

Awesome !

SELECT [t1].*
FROM (
   SELECT ROW_NUMBER() OVER (
   ORDER BY [t0].<primarykey>) AS [ROW_NUMBER],  [t0].*
   FROM [dbo].[<tablename>] AS [t0]
) AS [t1]
WHERE [t1].[ROW_NUMBER] BETWEEN <fromrow> AND <torow>
ORDER BY [t1].[ROW_NUMBER]

Download the following.

http://go.microsoft.com/fwlink/?LinkID=188039

The "Silverlight managed debugging package" is part of the developer runtime, not the SDK or Tools.  Make sure you have the latest version of the developer runtime installed (available at http://go.microsoft.com/fwlink/?LinkID=188039)

Snapshot transactions work like this:

When the SNAPSHOT isolation level is enabled, each time a row is updated, the SQL Server Database Engine stores a copy of the original row in tempdb, and adds a transaction sequence number to the row.

This ensures that the table is not locked while in tranaction(s).

If a snapshot transaction attempts to commit an update to a row that was changed after the transaction began, the transaction is rolled back, and an error is raised.

To enable it, use following script ( This will not hang like other examples )

declare @sql varchar(8000)

select @sql = ‘
ALTER DATABASE Libomcore SET SINGLE_USER WITH ROLLBACK
IMMEDIATE ;
ALTER DATABASE Libomcore SET READ_COMMITTED_SNAPSHOT ON;
ALTER DATABASE Libomcore SET MULTI_USER;
ALTER DATABASE Libomcore SET ALLOW_SNAPSHOT_ISOLATION ON;
‘
Exec(@sql)

public Image GetThumbnail(FileInfo from, Size size)
      {
          try
          {
              Image image = Bitmap.FromFile(from.ToString());

              int width = size.Width;
              int height = size.Height;

              if (image.Width > image.Height)
                  height = width * image.Height / image.Width;
              else
                  width = height * image.Width / image.Height;

              if (width > size.Width)
              {
                  width = size.Width;
                  height = width * image.Height / image.Width;
              }
              if (height > size.Height)
              {
                  height = size.Height;
                  width = height * image.Width / image.Height;
              }

              Image returnImage = new Bitmap(size.Width, size.Height);

              Graphics graphics = Graphics.FromImage(returnImage);
              graphics.SmoothingMode = SmoothingMode.HighQuality;
              graphics.CompositingQuality = CompositingQuality.HighQuality;
              graphics.InterpolationMode = InterpolationMode.High;

              graphics.FillRectangle(new SolidBrush(Color.White), 0, 0, returnImage.Width, returnImage.Height);

              graphics.DrawImage(image, new Rectangle((size.Width - width) / 2, (size.Height - height) / 2, width, height), new Rectangle(0, 0, image.Width, image.Height), GraphicsUnit.Pixel);

              return returnImage;
          }
          catch (Exception exception)
          {
          }

          return null;
      }

 

To save it, just use image.save(…); with the result

This is the setup. I have a class:

public class MyClass
{
    public int MyValue { get; set; }
    public int MyOtherValue { get; set; }
}

And two lists:

List<MyClass> list1 = new List<MyClass>();
list1.Add(new MyClass() { MyValue = 1, MyOtherValue = 10 });
list1.Add(new MyClass() { MyValue = 2, MyOtherValue = 20 });
list1.Add(new MyClass() { MyValue = 3, MyOtherValue = 30 });
list1.Add(new MyClass() { MyValue = 4, MyOtherValue = 40 });

List<MyClass> list2 = new List<MyClass>();
list2.Add(new MyClass() { MyValue = 2, MyOtherValue = 50 });
list2.Add(new MyClass() { MyValue = 3, MyOtherValue = 60 });

I want to remove all list2 instances from list1 matching on MyValue property.

Method 1: Loop and LINQ

list2.ForEach(l2 => { list1.RemoveAll(l1 => l1.MyValue == l2.MyValue); });

Method 2: LINQ and Loop

            (from l1 in list1 join l2 in list2 on l1.MyValue equals l2.MyValue
             select l1).ToList().ForEach(i => list1.Remove(i));

Output (from both)

MyValue: 1 MyOtherValue: 10
MyValue: 4 MyOtherValue: 40

Performance
Don’t be fooled that Method1 may look prettier than Method2. Performance depends on the size of the lists. Method1 scales very badly when list2 has more than a few elements compared to the size of list1.

List1 size: 1.000.000
{
     List2 size: 10
     Method 1: 103 ms
     Method 2: 325 ms

     List2 size: 100
     Method 1: 5534 ms
     Method 2: 682 ms
}

List1 size: 1.000
{
     List2 size: 100
     Method 1: 1 ms
     Method 2: 11 ms

     List2 size: 900
     Method 1: 32 ms
     Method 2: 12 ms
}

And it gets all bad when both lists are large:

List1 size: 100.000
{
     List2 size: 90.000
     Method 1: 297834 ms
     Method 2: 7555 ms
}

Conclusion
Use Method2 unless you are sure that the list that you want to remove is very small compared to the main list (<50 elements).