rikkus

[C#] On Line splitting optimization

2009-12-13T12:16:06-08:00

How about a more standard word wrapping algorithm? The simple 'minimum length' algorithm mentioned here http://en.wikipedia.org/wiki/Word_wrap should suit.

[C#] On Generic Lists of Different Types

2009-05-13T08:49:49-07:00

Implement Status.Load as you see fit. Obviously you'll want to load User from the "user" element contained within.

public IEnumerable<IStatus> ResponseHandler(string responseText, string unused)
{
    return ResponseHandler(responseText);
}

public IEnumerable<IStatus> ResponseHandler(string responseText)
{
    var element = XElement.Parse(responseText);

    if (element.Name == "statuses")
    {
        foreach (var statusElement in element.Descendants("status"))
        {
            yield return Status.Load(statusElement);
        }
    }
    else
    {
        yield return Status.Load(element);
    }
}

[C#] On Find random point inside a tree of geometrical object

2009-05-07T15:38:05-07:00

The easiest way to choose a random subvolume would probably be as shown. Also note that I don't recognise Random.NextDouble() - In .NET that's not a static method, for good reason: You generally have to initialise a Random object with a seed before using it.

Subvolumes.Skip(random.Next(Subvolumes.Count)).First()

[C#] On Method to read Network stream from Socket

2009-03-21T16:28:00-07:00

If you want to perform an HTTP request, you should use WebRequest:

http://msdn.microsoft.com/en-us/library/system.net.webrequest.aspx

Your code is incorrect because it claims to 'read fully' but may, even if there is no error, return less than the 'full' data.

[C#] On DirectoryInfo.CopyTo

2008-11-11T20:17:38-08:00

Here's a quick sketch of some improvements I'd make. This probably has lots of problems remaining, for example, I didn't deal with links either!

Cheers,
Rik

namespace Whatever
{
    public static class FileUtils
    {
        public void CopyDirectory
        (
            string sourcePath,
            string destinationPath,
            ExistingDestinationDirectoryPolicy existingDestinationDirectoryPolicy
        )
        {
            if (!Directory.Exists(sourcePath))
            {
                throw new DirectoryNotFoundException(string.Format("Source directory not found: {0}", sourcePath));
            }

            if (Directory.Exists(destinationPath))
            {
                bool cancel = false;

                ApplyExistingDestinationDirectoryPolicy(destinationPath, existingDestinationDirectoryPolicy, ref cancel);

                if (cancel)
                {
                    return;
                }
            }
            else
            {
                Directory.CreateDirectory(destinationPath);
            }

            CopyDirectories(sourcePath, existingDestinationDirectoryPolicy);
            CopyFiles(sourcePath, destinationPath);
        }

        private void CopyDirectories(string sourceDirectoryPath, ExistingDestinationDirectoryPolicy existingDestinationDirectoryPolicy)
        {
            foreach (var directoryPath in Directory.GetDirectories(sourceDirectoryPath))
            {
                CopyDirectory
                (
                    directoryPath,
                    Path.Combine(sourceDirectoryPath, Path.GetFileName(directoryPath)),
                    existingDestinationDirectoryPolicy
                );
            }
        }

        private static void CopyFiles(string sourceDirectoryPath, string destinationDirectoryPath)
        {
            foreach (var filePath in Directory.GetFiles(sourceDirectoryPath))
            {
                File.Copy(filePath, Path.Combine(Path.GetFileName(filePath), destinationDirectoryPath));
            }
        }

        private static void ApplyExistingDestinationDirectoryPolicy
            (
                string destinationPath,
                ExistingDestinationDirectoryPolicy existingDestinationDirectoryPolicy,
                ref bool cancel
            )
        {
            switch (existingDestinationDirectoryPolicy)
            {
                case ExistingDestinationDirectoryPolicy.DeleteExisting:
                    Directory.Delete(destinationPath, true /* recursive */);
                    break;

                case ExistingDestinationDirectoryPolicy.CancelOnExisting:
                    cancel = true;
                    break;

                case ExistingDestinationDirectoryPolicy.ThrowOnExisting:
                    throw new DirectoryExistsException(destinationPath);

                default:
                    // Carry on!
                    break;
            }
        }
    }
}

[C#] On Sorting by dependencies

2008-11-06T11:31:10-08:00

The real world scenario is adding user-defined functions to a SQL Server database.

The functions must be created in order, such that when a function is created, the ones upon which it depends (those which it calls) have already been created.

For example: I may write a function Foo which calls another function Bar. Function Bar must be created before I can create Foo, or the compiler will complain.

The data structure expected as input by this (genericised) algorithm is a set of references to nodes, each paired with a collection of references to nodes upon which it depends.

[Ruby] On xml rss feed

2008-11-05T12:47:54-08:00

It looks like you're concatenating plain text and HTML. Perhaps you should make your description HTML and embed the link inside it using standard XML tools?

[C#] On Sorting by dependencies

2008-11-05T12:16:02-08:00

Simple demo program.

foreach (var item in
    DependencySorter<int>.Sort
    (
        new Dictionary<int, IEnumerable<int>>
        {
            {5, new int[] {4, 3, 2}},
            {2, new int[] {1}},
            {1, new int[] {}},
            {4, new int[] {3}},
            {3, new int[] {1, 2}}
        }
    )
)
{
    Console.WriteLine(item);
}

[C#] Sorting by dependencies

2008-11-05T12:14:53-08:00

This code sorts a collection by the dependencies of its contents.

It is passed a dictionary mapping a key to a set of keys - the dependencies of that key.

I knocked up this code quickly and realised as I wrote it that it was likely to blow the stack on a large data set due to its recursive nature. I'd try to make it tail recursive, but the C# compiler doesn't take advantage of that yet, so it should probably be iterative. I'd be interested to see any improved solution.

public static class DependencySorter<T>
{
    public static IEnumerable<T> Sort(Dictionary<T, IEnumerable<T>> dependencies)
    {
        var visited = new Dictionary<T, bool>();

        foreach (var key in dependencies.Keys)
        {
            visited[key] = false;
        }

        foreach (var key in dependencies.Keys)
        {
            foreach (var ordered in Search(key, dependencies, visited))
                yield return ordered;
        }
    }

    private static IEnumerable<T> Search
    (
        T key,
        IDictionary<T, IEnumerable<T>> dependencies,
        IDictionary<T, bool> visited
    )
    {
        if (!visited[key])
        {
            visited[key] = true;

            foreach (T value in dependencies[key])
            {
                foreach (var ordered in Search(value, dependencies, visited))
                {
                    yield return ordered;
                }
            }

            yield return key;
        }
    }
}

[C#] On Drop all Indexes in SQL Server

2008-10-07T12:13:01-07:00

I had to ask because often people want to recreate the indexes, in which case DBCC REINDEX is a much better idea.

Here's my version, which is pretty much the same as yours, except uses a cursor as it's a little neater.

You may want to add a check that you're not operating on sysdiagrams, as this logic will drops its indexes, too.

## Transact-SQL [sql]

DECLARE @indexName VARCHAR(128)
DECLARE @tableName VARCHAR(128)

DECLARE [indexes] CURSOR FOR
	
	SELECT		[sysindexes].[name] AS [Index],
			[sysobjects].[name] AS [Table]
	
	FROM		[sysindexes]
	
	INNER JOIN	[sysobjects]
	ON		[sysindexes].[id] = [sysobjects].[id]
	
	WHERE		[sysindexes].[name] IS NOT NULL
	AND		[sysobjects].[type] = 'U'

OPEN [indexes]

FETCH NEXT FROM [indexes] INTO @indexName, @tableName

WHILE @@FETCH_STATUS = 0
BEGIN
	PRINT 'DROP INDEX [' + @indexName + '] ON [' + @tableName + ']'

	FETCH NEXT FROM [indexes] INTO @indexName, @tableName
END

CLOSE		[indexes]
DEALLOCATE	[indexes]

[PHP] On Mortgage Calculator

2008-09-25T16:59:48-07:00

You're confusing the terms 'refactor' and 'reimplement'

[VB.NET] On Remove the Evil GOTO

2008-09-25T16:56:31-07:00

This kind of error handling is idiomatic in VB.

[C#] On Common StProc Code

2008-04-02T16:05:44-07:00

To be honest I haven't looked at this site much as I just added the C# feed to my feed reader when I found it - and then forgot about it, so I'm not really sure about ratings.

Your code looks good to me now - the only thing left that's bothering me is the naming of various things ('restore' should be perhaps 'reverse', there are too many abbrvtns for my liking, etc.)

Cheers!

[C#] On Common StProc Code

2008-04-02T15:11:49-07:00

See the comments by alazela here: http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=1742482&SiteID=1 - it looks like Prepare isn't going to do anything when you're calling a stored procedure, so you might as well take it out.

[C#] On Common StProc Code

2008-04-02T15:00:07-07:00

I'm not sure what the Prepare call does, so I'm afraid you'll have to see if someone else knows what should be done with it.