.net

WPF Scrollable + Zoomable + Dragable Control

Published by Thomas Christof on 21. März 2017

Unluckily there is no standard control to zoom, drag and scroll your content. My implementation is based on following tutorial. With this implementation you are able to zoom, drag and scroll arbitrary controls. Showcase ScrollDragZoomControl.xaml

<UserControl x:Class="MinimalMonitoringClient.Controls.ScrollDragZoomControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             Background="Transparent">

    <UserControl.Template>
        <ControlTemplate TargetType="UserControl">
            <ScrollViewer x:Name="scrollViewer"
                  Loaded="scrollViewer_Loaded"
                  HorizontalScrollBarVisibility="Visible"
                  VerticalScrollBarVisibility="Visible">

                <Grid Name="grid" RenderTransformOrigin="0.5,0.5">
                    <Grid.LayoutTransform>
                        <TransformGroup>
                            <ScaleTransform x:Name="scaleTransform" />
                        </TransformGroup>
                    </Grid.LayoutTransform>
                    <Viewbox>
                        <!-- Present the actual stuff the user wants to display -->
                        <ContentPresenter />
                    </Viewbox>
                </Grid>
            </ScrollViewer>
        </ControlTemplate>
    </UserControl.Template>
</UserControl>

<UserControl x:Class="MinimalMonitoringClient.Controls.ScrollDragZoomControl"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Background="Transparent">

<UserControl.Template>

<ScrollViewer x:Name="scrollViewer"

Loaded="scrollViewer_Loaded"

HorizontalScrollBarVisibility="Visible"

VerticalScrollBarVisibility="Visible">

<Grid.LayoutTransform>

</TransformGroup>

</Grid.LayoutTransform>

</Viewbox>

</Grid>

</ScrollViewer>

</ControlTemplate>

</UserControl.Template>

</UserControl>

ScrollDragZoomControl.xaml.cs

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;

namespace NAMESPACE
{
    /// <summary>
    /// Interaktionslogik für ScrollDragZoomControl.xaml
    /// </summary>
    public partial class ScrollDragZoomControl : UserControl
    {
        private int zoomLevel = 1;

        private ScaleTransform scaleTransform;
        private ScrollViewer scrollViewer;
        private Grid grid;

        Point? lastCenterPositionOnTarget;
        Point? lastMousePositionOnTarget;
        Point? lastDragPoint;

        public ScrollDragZoomControl()
        {
            InitializeComponent();
        }

        private void scrollViewer_Loaded(object sender, RoutedEventArgs e)
        {
            scaleTransform = (ScaleTransform)Template.FindName("scaleTransform", this);
            scrollViewer = (ScrollViewer)Template.FindName("scrollViewer", this);
            grid = (Grid)Template.FindName("grid", this);

            scrollViewer.ScrollChanged += OnScrollViewerScrollChanged;
            scrollViewer.MouseLeftButtonUp += OnMouseLeftButtonUp;
            scrollViewer.PreviewMouseLeftButtonUp += OnMouseLeftButtonUp;
            scrollViewer.PreviewMouseWheel += OnPreviewMouseWheel;
            scrollViewer.PreviewMouseLeftButtonDown += OnMouseLeftButtonDown;
            scrollViewer.MouseMove += OnMouseMove;
        }

        void OnMouseMove(object sender, MouseEventArgs e)
        {
            if (lastDragPoint.HasValue)
            {
                Point posNow = e.GetPosition(scrollViewer);

                double dX = posNow.X - lastDragPoint.Value.X;
                double dY = posNow.Y - lastDragPoint.Value.Y;

                lastDragPoint = posNow;

                scrollViewer.ScrollToHorizontalOffset(scrollViewer.HorizontalOffset - dX);
                scrollViewer.ScrollToVerticalOffset(scrollViewer.VerticalOffset - dY);
            }
        }

        void OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            var mousePos = e.GetPosition(scrollViewer);
            if (mousePos.X <= scrollViewer.ViewportWidth && mousePos.Y <
                scrollViewer.ViewportHeight) //make sure we still can use the scrollbars
            {
                scrollViewer.Cursor = Cursors.SizeAll;
                lastDragPoint = mousePos;
                Mouse.Capture(scrollViewer);
            }
        }

        void OnPreviewMouseWheel(object sender, MouseWheelEventArgs e)
        {
            lastMousePositionOnTarget = Mouse.GetPosition(grid);

            if (e.Delta > 0)
                zoomLevel++;
            else if (e.Delta < 0)
                zoomLevel--;

            zoomLevel = zoomLevel < 1 ? 1 : zoomLevel;

            scaleTransform.ScaleX = zoomLevel;
            scaleTransform.ScaleY = zoomLevel;

            var centerOfViewport = new Point(scrollViewer.ViewportWidth / 2, scrollViewer.ViewportHeight / 2);
            lastCenterPositionOnTarget = scrollViewer.TranslatePoint(centerOfViewport, grid);

            e.Handled = true;
        }

        void OnMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            scrollViewer.Cursor = Cursors.Arrow;
            scrollViewer.ReleaseMouseCapture();
            lastDragPoint = null;
        }

        void OnScrollViewerScrollChanged(object sender, ScrollChangedEventArgs e)
        {
            if (e.ExtentHeightChange != 0 || e.ExtentWidthChange != 0)
            {
                Point? targetBefore = null;
                Point? targetNow = null;

                if (!lastMousePositionOnTarget.HasValue)
                {
                    if (lastCenterPositionOnTarget.HasValue)
                    {
                        var centerOfViewport = new Point(scrollViewer.ViewportWidth / 2,
                                                         scrollViewer.ViewportHeight / 2);
                        Point centerOfTargetNow =
                              scrollViewer.TranslatePoint(centerOfViewport, grid);

                        targetBefore = lastCenterPositionOnTarget;
                        targetNow = centerOfTargetNow;
                    }
                }
                else
                {
                    targetBefore = lastMousePositionOnTarget;
                    targetNow = Mouse.GetPosition(grid);

                    lastMousePositionOnTarget = null;
                }

                if (targetBefore.HasValue)
                {
                    double dXInTargetPixels = targetNow.Value.X - targetBefore.Value.X;
                    double dYInTargetPixels = targetNow.Value.Y - targetBefore.Value.Y;

                    double multiplicatorX = e.ExtentWidth / grid.Width;
                    double multiplicatorY = e.ExtentHeight / grid.Height;

                    double newOffsetX = scrollViewer.HorizontalOffset -
                                        dXInTargetPixels * multiplicatorX;
                    double newOffsetY = scrollViewer.VerticalOffset -
                                        dYInTargetPixels * multiplicatorY;

                    if (double.IsNaN(newOffsetX) || double.IsNaN(newOffsetY))
                    {
                        return;
                    }

                    scrollViewer.ScrollToHorizontalOffset(newOffsetX);
                    scrollViewer.ScrollToVerticalOffset(newOffsetY);
                }
            }
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

using System.Windows;

using System.Windows.Controls;

using System.Windows.Input;

using System.Windows.Media;

namespace NAMESPACE

{

/// <summary>

/// Interaktionslogik für ScrollDragZoomControl.xaml

/// </summary>

public partial class ScrollDragZoomControl : UserControl

{

private int zoomLevel = 1;

private ScaleTransform scaleTransform;

private ScrollViewer scrollViewer;

private Grid grid;

Point? lastCenterPositionOnTarget;

Point? lastMousePositionOnTarget;

Point? lastDragPoint;

public ScrollDragZoomControl()

{

InitializeComponent();

}

private void scrollViewer_Loaded(object sender, RoutedEventArgs e)

{

scaleTransform = (ScaleTransform)Template.FindName("scaleTransform", this);

scrollViewer = (ScrollViewer)Template.FindName("scrollViewer", this);

grid = (Grid)Template.FindName("grid", this);

scrollViewer.ScrollChanged += OnScrollViewerScrollChanged;

scrollViewer.MouseLeftButtonUp += OnMouseLeftButtonUp;

scrollViewer.PreviewMouseLeftButtonUp += OnMouseLeftButtonUp;

scrollViewer.PreviewMouseWheel += OnPreviewMouseWheel;

scrollViewer.PreviewMouseLeftButtonDown += OnMouseLeftButtonDown;

scrollViewer.MouseMove += OnMouseMove;

}

void OnMouseMove(object sender, MouseEventArgs e)

{

if (lastDragPoint.HasValue)

{

Point posNow = e.GetPosition(scrollViewer);

double dX = posNow.X - lastDragPoint.Value.X;

double dY = posNow.Y - lastDragPoint.Value.Y;

lastDragPoint = posNow;

scrollViewer.ScrollToHorizontalOffset(scrollViewer.HorizontalOffset - dX);

scrollViewer.ScrollToVerticalOffset(scrollViewer.VerticalOffset - dY);

}

void OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)

{

var mousePos = e.GetPosition(scrollViewer);

if (mousePos.X <= scrollViewer.ViewportWidth && mousePos.Y <

scrollViewer.ViewportHeight) //make sure we still can use the scrollbars

{

scrollViewer.Cursor = Cursors.SizeAll;

lastDragPoint = mousePos;

Mouse.Capture(scrollViewer);

}

void OnPreviewMouseWheel(object sender, MouseWheelEventArgs e)

{

lastMousePositionOnTarget = Mouse.GetPosition(grid);

if (e.Delta > 0)

zoomLevel++;

else if (e.Delta < 0)

zoomLevel--;

zoomLevel = zoomLevel < 1 ? 1 : zoomLevel;

scaleTransform.ScaleX = zoomLevel;

scaleTransform.ScaleY = zoomLevel;

var centerOfViewport = new Point(scrollViewer.ViewportWidth / 2, scrollViewer.ViewportHeight / 2);

lastCenterPositionOnTarget = scrollViewer.TranslatePoint(centerOfViewport, grid);

e.Handled = true;

}

void OnMouseLeftButtonUp(object sender, MouseButtonEventArgs e)

{

scrollViewer.Cursor = Cursors.Arrow;

scrollViewer.ReleaseMouseCapture();

lastDragPoint = null;

}

void OnScrollViewerScrollChanged(object sender, ScrollChangedEventArgs e)

{

if (e.ExtentHeightChange != 0 || e.ExtentWidthChange != 0)

{

Point? targetBefore = null;

Point? targetNow = null;

if (!lastMousePositionOnTarget.HasValue)

{

if (lastCenterPositionOnTarget.HasValue)

{

var centerOfViewport = new Point(scrollViewer.ViewportWidth / 2,

scrollViewer.ViewportHeight / 2);

Point centerOfTargetNow =

scrollViewer.TranslatePoint(centerOfViewport, grid);

targetBefore = lastCenterPositionOnTarget;

targetNow = centerOfTargetNow;

}

else

{

targetBefore = lastMousePositionOnTarget;

targetNow = Mouse.GetPosition(grid);

lastMousePositionOnTarget = null;

}

if (targetBefore.HasValue)

{

double dXInTargetPixels = targetNow.Value.X - targetBefore.Value.X;

double dYInTargetPixels = targetNow.Value.Y - targetBefore.Value.Y;

double multiplicatorX = e.ExtentWidth / grid.Width;

double multiplicatorY = e.ExtentHeight / grid.Height;

double newOffsetX = scrollViewer.HorizontalOffset -

dXInTargetPixels * multiplicatorX;

double newOffsetY = scrollViewer.VerticalOffset -

dYInTargetPixels * multiplicatorY;

if (double.IsNaN(newOffsetX) || double.IsNaN(newOffsetY))

{

return;

}

scrollViewer.ScrollToHorizontalOffset(newOffsetX);

scrollViewer.ScrollToVerticalOffset(newOffsetY);

}

Usage Add the “ScrollDragZoomControl” to your project and use it as follows:

    <controls:ScrollDragZoomControl>
        <!-- Your Content to present -->
    </controls:ScrollDragZoomControl>

<controls:ScrollDragZoomControl>

</controls:ScrollDragZoomControl>

Windows Phone 8.1 WinRT Json Serialize + DeSerialize

Published by Thomas Christof on 15. August 2016

        private static string JSON_MARK_FILE_NAME = "markJsonData.json";

1	private static string JSON_MARK_FILE_NAME = "markJsonData.json";

Serialize object to a storage file

            StorageFolder localFolder = ApplicationData.Current.LocalFolder;
            StorageFile textFile = await localFolder.CreateFileAsync(JSON_MARK_FILE_NAME, CreationCollisionOption.ReplaceExisting);
            using (Stream stream = await textFile.OpenStreamForWriteAsync())
            {
                string content = await Newtonsoft.Json.JsonConvert.SerializeObjectAsync(grades);
                using (StreamWriter streamWriter = new StreamWriter(stream))
                    await streamWriter.WriteAsync(content);
            }

StorageFolder localFolder = ApplicationData.Current.LocalFolder;

StorageFile textFile = await localFolder.CreateFileAsync(JSON_MARK_FILE_NAME, CreationCollisionOption.ReplaceExisting);

using (Stream stream = await textFile.OpenStreamForWriteAsync())

{

string content = await Newtonsoft.Json.JsonConvert.SerializeObjectAsync(grades);

using (StreamWriter streamWriter = new StreamWriter(stream))

await streamWriter.WriteAsync(content);

}

DeSerialize a storage file to a object

            StorageFolder localFolder = ApplicationData.Current.LocalFolder;
            StorageFile textFile = await localFolder.GetFileAsync(JSON_MARK_FILE_NAME);
            using (IRandomAccessStream stream = await textFile.OpenReadAsync())
            using (StreamReader streamReader = new StreamReader(stream.AsStreamForRead()))
                return await Newtonsoft.Json.JsonConvert.DeserializeObjectAsync<List<Grade>>((await streamReader.ReadToEndAsync()));

StorageFolder localFolder = ApplicationData.Current.LocalFolder;

StorageFile textFile = await localFolder.GetFileAsync(JSON_MARK_FILE_NAME);

using (IRandomAccessStream stream = await textFile.OpenReadAsync())

using (StreamReader streamReader = new StreamReader(stream.AsStreamForRead()))

return await Newtonsoft.Json.JsonConvert.DeserializeObjectAsync<List<Grade>>((await streamReader.ReadToEndAsync()));

Check if the storage file exists before you call GetFileAsync. (Which is ignored at the example above)

Rabin-Karp

Published by Thomas Christof on 24. Januar 2016

        internal override SearchResult Search(string text, string pattern)
        {
            if (pattern.Length > text.Length) return SearchResult.Empty();

            SearchResult searchResult = new SearchResult() { Matches = new List<Match>() };
            int patternHashValue = pattern.GetHashCode();
            for(int index = 0; index + pattern.Length < text.Length; index++)
            {
                string indexString = text.Substring(index, pattern.Length);
                int indexHashValue = indexString.GetHashCode();
                if(patternHashValue == indexHashValue)
                    if (string.CompareOrdinal(pattern, indexString) == 0)
                        searchResult.AddMatch(new Match() { Position = index });
            }

            return searchResult;
        }

internal override SearchResult Search(string text, string pattern)

{

if (pattern.Length > text.Length) return SearchResult.Empty();

SearchResult searchResult = new SearchResult() { Matches = new List<Match>() };

int patternHashValue = pattern.GetHashCode();

for(int index = 0; index + pattern.Length < text.Length; index++)

{

string indexString = text.Substring(index, pattern.Length);

int indexHashValue = indexString.GetHashCode();

if(patternHashValue == indexHashValue)

if (string.CompareOrdinal(pattern, indexString) == 0)

searchResult.AddMatch(new Match() { Position = index });

}

return searchResult;

}

Heapsort

Published by Thomas Christof on 23. Januar 2016

internal class Heap : StorageObjectSort
    {
        private object[] items;

        public int Size { get; set; } = 0;

        public override IEnumerable<T> Sort<T>(IComparer<T> sortFunction, IEnumerable<T> collection)
        {
            List<T> objectList = collection.ToList();
            Initialize(objectList.Count);
            objectList.ForEach(o => Insert(o, sortFunction));
            objectList.Clear();

            while (Size > 0)
                objectList.Add((T)Remove(sortFunction));
            return objectList;
        }

        protected override void Insert<T>(object item, IComparer<T> sortFunction)
        {
            items[Size] = item;
            Size++;

            UpHeap(sortFunction);
        }

        protected override object Remove<T>(IComparer<T> sortFunction)
        {
            object buffer = items[0];
            items[0] = null;
            Size--;

            DownHeap(sortFunction);
            return buffer;
        }

        private void Initialize(int count)
        {
            items = new object[count];
        }

        private void Swap(int first, int second)
        {
            object buffer = items[first];
            items[first] = items[second];
            items[second] = buffer;
        }

        private int GetLeftChild(int index)
        {
            return GetRightChild(index) - 1;
        }

        private int GetRightChild(int index)
        {
            return 2 * (index + 1);
        }

        private int GetParent(int index)
        {
            return (index + 1) / 2 - 1;
        }

        private void UpHeap<T>(IComparer<T> sortFunction)
        {
            if (Size <= 1) return;

            int currentElement = Size - 1;
            int currentElementParent = GetParent(currentElement);
            while(currentElementParent >= 0 && sortFunction.Compare((T)items[currentElementParent], (T)items[currentElement]) > 0)
            {
                Swap(currentElement, currentElementParent);
                currentElement = currentElementParent;
                currentElementParent = GetParent(currentElement);
            }
        }

        private void DownHeap<T>(IComparer<T> sortFunction)
        {
            int currentIndex = 0;
            int leftChild = GetLeftChild(currentIndex);
            int rightChild = GetRightChild(currentIndex);
            while (leftChild < items.Length || rightChild < items.Length)
            {
                int smallerChild = GetSmallerChild<T>(sortFunction, leftChild, rightChild);
                if (smallerChild == -1) return; //There is no smaller child.

                if (items[currentIndex] == null || sortFunction.Compare((T)items[smallerChild], (T)items[currentIndex]) < 0)
                {
                    Swap(smallerChild, currentIndex);
                    currentIndex = smallerChild;
                    leftChild = GetLeftChild(currentIndex);
                    rightChild = GetRightChild(currentIndex);
                    continue;
                }

                return;
            }
        }

        private int GetSmallerChild<T>(IComparer<T> sortFunction, int first, int second)
        {
            if (first >= items.Length) return second;
            else if (second >= items.Length) return first;
            else if (items[first] != null && items[second] == null) return first;
            else if (items[second] != null && items[first] == null) return second;
            else if (items[first] == null && items[second] == null) return -1;
            return (sortFunction.Compare((T)items[first], (T)items[second]) < 0) ? first : second;
        }
    }

100

101

102

103

104

105

106

107

108

109

110

internal class Heap : StorageObjectSort

{

private object[] items;

public int Size { get; set; } = 0;

public override IEnumerable<T> Sort<T>(IComparer<T> sortFunction, IEnumerable<T> collection)

{

List<T> objectList = collection.ToList();

Initialize(objectList.Count);

objectList.ForEach(o => Insert(o, sortFunction));

objectList.Clear();

while (Size > 0)

objectList.Add((T)Remove(sortFunction));

return objectList;

}

protected override void Insert<T>(object item, IComparer<T> sortFunction)

{

items[Size] = item;

Size++;

UpHeap(sortFunction);

}

protected override object Remove<T>(IComparer<T> sortFunction)

{

object buffer = items[0];

items[0] = null;

Size--;

DownHeap(sortFunction);

return buffer;

}

private void Initialize(int count)

{

items = new object[count];

}

private void Swap(int first, int second)

{

object buffer = items[first];

items[first] = items[second];

items[second] = buffer;

}

private int GetLeftChild(int index)

{

return GetRightChild(index) - 1;

}

private int GetRightChild(int index)

{

return 2 * (index + 1);

}

private int GetParent(int index)

{

return (index + 1) / 2 - 1;

}

private void UpHeap<T>(IComparer<T> sortFunction)

{

if (Size <= 1) return;

int currentElement = Size - 1;

int currentElementParent = GetParent(currentElement);

while(currentElementParent >= 0 && sortFunction.Compare((T)items[currentElementParent], (T)items[currentElement]) > 0)

{

Swap(currentElement, currentElementParent);

currentElement = currentElementParent;

currentElementParent = GetParent(currentElement);

}

private void DownHeap<T>(IComparer<T> sortFunction)

{

int currentIndex = 0;

int leftChild = GetLeftChild(currentIndex);

int rightChild = GetRightChild(currentIndex);

while (leftChild < items.Length || rightChild < items.Length)

{

int smallerChild = GetSmallerChild<T>(sortFunction, leftChild, rightChild);

if (smallerChild == -1) return; //There is no smaller child.

if (items[currentIndex] == null || sortFunction.Compare((T)items[smallerChild], (T)items[currentIndex]) < 0)

{

Swap(smallerChild, currentIndex);

currentIndex = smallerChild;

leftChild = GetLeftChild(currentIndex);

rightChild = GetRightChild(currentIndex);

continue;

}

return;

}

private int GetSmallerChild<T>(IComparer<T> sortFunction, int first, int second)

{

if (first >= items.Length) return second;

else if (second >= items.Length) return first;

else if (items[first] != null && items[second] == null) return first;

else if (items[second] != null && items[first] == null) return second;

else if (items[first] == null && items[second] == null) return -1;

return (sortFunction.Compare((T)items[first], (T)items[second]) < 0) ? first : second;

}

Combosort

Published by Thomas Christof on 5. November 2015

        public override IEnumerable<T> Sort<T>(IComparer<T> sortFunction, IEnumerable<T> collection)
        {
            List<T> objectList = collection.ToList();

            //Calculate an efficient step size.
            //Ofc it depends on many factors and it won't be perfect in every case.
            int divideValue = (int)Math.Pow(objectList.Count, 1 / 3);

            for (int partCount = divideValue; partCount > 0; partCount--)
            {
                //Split the objectList up into smaller lists and sort them parallel.
                List<List<T>> listParts = new List<List<T>>();
                int elementsPerPart = objectList.Count / partCount;
                bool isEvenCollection = ((float)(objectList.Count / partCount)) % 1 == 0;

                for (int listPartIndex = 0; listPartIndex < partCount; listPartIndex++)
                {
                    listParts.Add(objectList.GetRange(listPartIndex * elementsPerPart, elementsPerPart));
                    if (!isEvenCollection && listPartIndex == partCount - 1) //It is not an even number. We have to handle the uneven element.
                        listParts[listParts.Count - 1].Add(objectList.ElementAt((listPartIndex * elementsPerPart) + elementsPerPart));
                }

                //Sort all the lists with the bubblesort.
                Parallel.ForEach(listParts, (currentCollection) =>
                {
                    listParts[listParts.IndexOf(listParts.Where(currentListPart => currentListPart.Equals(currentCollection)).Single())] =
                    SortFactory.Sort(sortFunction, currentCollection, SortMethod.Bubble).ToList();
                });

                //Create a temporary array which will get all the sorted results.
                T[] newObjectArray = new T[listParts.Sum(currentListPart => currentListPart.Count)];
                for (int listPartIndex = 0; listPartIndex < partCount; listPartIndex++)
                    Array.Copy(listParts[listPartIndex].ToArray(), 0, newObjectArray, listPartIndex * elementsPerPart, listParts[listPartIndex].Count);
                objectList = newObjectArray.ToList();
            }

            return objectList;
        }
    }

public override IEnumerable<T> Sort<T>(IComparer<T> sortFunction, IEnumerable<T> collection)

{

List<T> objectList = collection.ToList();

//Calculate an efficient step size.

//Ofc it depends on many factors and it won't be perfect in every case.

int divideValue = (int)Math.Pow(objectList.Count, 1 / 3);

for (int partCount = divideValue; partCount > 0; partCount--)

{

//Split the objectList up into smaller lists and sort them parallel.

List<List<T>> listParts = new List<List<T>>();

int elementsPerPart = objectList.Count / partCount;

bool isEvenCollection = ((float)(objectList.Count / partCount)) % 1 == 0;

for (int listPartIndex = 0; listPartIndex < partCount; listPartIndex++)

{

listParts.Add(objectList.GetRange(listPartIndex * elementsPerPart, elementsPerPart));

if (!isEvenCollection && listPartIndex == partCount - 1) //It is not an even number. We have to handle the uneven element.

listParts[listParts.Count - 1].Add(objectList.ElementAt((listPartIndex * elementsPerPart) + elementsPerPart));

}

//Sort all the lists with the bubblesort.

Parallel.ForEach(listParts, (currentCollection) =>

{

listParts[listParts.IndexOf(listParts.Where(currentListPart => currentListPart.Equals(currentCollection)).Single())] =

SortFactory.Sort(sortFunction, currentCollection, SortMethod.Bubble).ToList();

});

//Create a temporary array which will get all the sorted results.

T[] newObjectArray = new T[listParts.Sum(currentListPart => currentListPart.Count)];

for (int listPartIndex = 0; listPartIndex < partCount; listPartIndex++)

Array.Copy(listParts[listPartIndex].ToArray(), 0, newObjectArray, listPartIndex * elementsPerPart, listParts[listPartIndex].Count);

objectList = newObjectArray.ToList();

}

return objectList;

}

Shellsort

Published by Thomas Christof on 5. November 2015

        public override IEnumerable<T> Sort<T>(IComparer<T> sortFunction, IEnumerable<T> collection)
        {
            List<T> objectList = collection.ToList();

            //Calculate an efficient step size.
            //Ofc it depends on many factors and it won't be perfect in every case.
            int divideValue = (int)Math.Pow(objectList.Count, 1 / 3);

            for (int partCount = divideValue; partCount > 0; partCount--)
            {
                //Split the objectList up into smaller lists and sort them parallel.
                List<List<T>> listParts = new List<List<T>>();
                int elementsPerPart = objectList.Count / partCount;
                bool isEvenCollection = ((float)(objectList.Count / partCount)) % 1 == 0;

                for (int listPartIndex = 0; listPartIndex < partCount; listPartIndex++)
                {
                    listParts.Add(objectList.GetRange(listPartIndex * elementsPerPart, elementsPerPart));
                    if (!isEvenCollection && listPartIndex == partCount - 1) //It is not an even number. We have to handle the uneven element.
                        listParts[listParts.Count - 1].Add(objectList.ElementAt((listPartIndex * elementsPerPart) + elementsPerPart));
                }

                //Sort all the lists with the insertionsort.
                Parallel.ForEach(listParts, (currentCollection) =>
                {
                    listParts[listParts.IndexOf(listParts.Where(currentListPart => currentListPart.Equals(currentCollection)).Single())] = 
                    SortFactory.Sort(sortFunction, currentCollection, SortMethod.Insertion).ToList();
                });

                //Create a temporary array which will get all the sorted results.
                T[] newObjectArray = new T[listParts.Sum(currentListPart => currentListPart.Count)];
                for (int listPartIndex = 0; listPartIndex < partCount; listPartIndex++)
                    Array.Copy(listParts[listPartIndex].ToArray(), 0, newObjectArray, listPartIndex * elementsPerPart, listParts[listPartIndex].Count);
                objectList = newObjectArray.ToList();
            }

            return objectList;
        }

public override IEnumerable<T> Sort<T>(IComparer<T> sortFunction, IEnumerable<T> collection)

{

List<T> objectList = collection.ToList();

//Calculate an efficient step size.

//Ofc it depends on many factors and it won't be perfect in every case.

int divideValue = (int)Math.Pow(objectList.Count, 1 / 3);

for (int partCount = divideValue; partCount > 0; partCount--)

{

//Split the objectList up into smaller lists and sort them parallel.

List<List<T>> listParts = new List<List<T>>();

int elementsPerPart = objectList.Count / partCount;

bool isEvenCollection = ((float)(objectList.Count / partCount)) % 1 == 0;

for (int listPartIndex = 0; listPartIndex < partCount; listPartIndex++)

{

listParts.Add(objectList.GetRange(listPartIndex * elementsPerPart, elementsPerPart));

if (!isEvenCollection && listPartIndex == partCount - 1) //It is not an even number. We have to handle the uneven element.

listParts[listParts.Count - 1].Add(objectList.ElementAt((listPartIndex * elementsPerPart) + elementsPerPart));

}

//Sort all the lists with the insertionsort.

Parallel.ForEach(listParts, (currentCollection) =>

{

listParts[listParts.IndexOf(listParts.Where(currentListPart => currentListPart.Equals(currentCollection)).Single())] =

SortFactory.Sort(sortFunction, currentCollection, SortMethod.Insertion).ToList();

});

//Create a temporary array which will get all the sorted results.

T[] newObjectArray = new T[listParts.Sum(currentListPart => currentListPart.Count)];

for (int listPartIndex = 0; listPartIndex < partCount; listPartIndex++)

Array.Copy(listParts[listPartIndex].ToArray(), 0, newObjectArray, listPartIndex * elementsPerPart, listParts[listPartIndex].Count);

objectList = newObjectArray.ToList();

}

return objectList;

}

Inserationsort

Published by Thomas Christof on 5. November 2015

    internal class Insertion : ObjectSort
    {
        public override IEnumerable<T> Sort<T>(IComparer<T> sortFunction, IEnumerable<T> collection)
        {
            List<T> objectList = collection.ToList();

            for (int currentIndex = 1; currentIndex < objectList.Count; currentIndex++)
            {
                //Put the current object into a buffer.
                T objectBuffer = objectList[currentIndex];

                //The index we have to shift.
                int shiftIndex = 0; //Shift all from 0 to the current index.

                //Climb down all the elements from the current index till 0.
                //Search for a smaller element than objectBuffer.
                for(int lowerIndex = currentIndex - 1; lowerIndex >= 0; lowerIndex--)
                {
                    bool isSmaller = (sortFunction.Compare(objectList[lowerIndex], objectList[currentIndex]) > 0);
                    if (isSmaller) continue; //We want the smallest element in the list.
                    shiftIndex = lowerIndex + 1;
                    break; //No more comparisons necessary.
                }

                if (currentIndex == shiftIndex) continue;
                T[] newObjectArray = new T[objectList.Count];
                objectList.CopyTo(currentIndex + 1, newObjectArray, currentIndex + 1, newObjectArray.Length - (currentIndex + 1));
                objectList.CopyTo(shiftIndex, newObjectArray, shiftIndex + 1, currentIndex - shiftIndex);
                if (shiftIndex > 0) objectList.CopyTo(0, newObjectArray, 0, shiftIndex);
                newObjectArray[shiftIndex] = objectBuffer;
                objectList = newObjectArray.ToList();
            }

            return objectList;
        }
    }

internal class Insertion : ObjectSort

{

public override IEnumerable<T> Sort<T>(IComparer<T> sortFunction, IEnumerable<T> collection)

{

List<T> objectList = collection.ToList();

for (int currentIndex = 1; currentIndex < objectList.Count; currentIndex++)

{

//Put the current object into a buffer.

T objectBuffer = objectList[currentIndex];

//The index we have to shift.

int shiftIndex = 0; //Shift all from 0 to the current index.

//Climb down all the elements from the current index till 0.

//Search for a smaller element than objectBuffer.

for(int lowerIndex = currentIndex - 1; lowerIndex >= 0; lowerIndex--)

{

bool isSmaller = (sortFunction.Compare(objectList[lowerIndex], objectList[currentIndex]) > 0);

if (isSmaller) continue; //We want the smallest element in the list.

shiftIndex = lowerIndex + 1;

break; //No more comparisons necessary.

}

if (currentIndex == shiftIndex) continue;

T[] newObjectArray = new T[objectList.Count];

objectList.CopyTo(currentIndex + 1, newObjectArray, currentIndex + 1, newObjectArray.Length - (currentIndex + 1));

objectList.CopyTo(shiftIndex, newObjectArray, shiftIndex + 1, currentIndex - shiftIndex);

if (shiftIndex > 0) objectList.CopyTo(0, newObjectArray, 0, shiftIndex);

newObjectArray[shiftIndex] = objectBuffer;

objectList = newObjectArray.ToList();

}

return objectList;

}

Iteration performance – Vergleich

Published by Thomas Christof on 11. Februar 2014

Es gibt viele Möglichkeiten eine Ansammlung von Daten mithilfe einer Iteration zu durchlaufen. Die verwendete Iteration hängt meistens von der Sachlage ab. Wird ein Index benötigt. Auf wie viel Objektvariablen wird zugegriffen. Muss das Objekt noch convertiert oder gecastet werden. … Jedoch welche Iterationsmethode ist die performanteste? Welcher Durchlauf ist am schnellsten? Zur Auswahl steht ForEach …