Posted by jpluimers on 2012/03/02
Hopefully they will add Visual Studio 2011 ISOs (no, not the current ones that still download the prerequisites in the background) like they did with the Windows 8 Consumer Preview ISOs:
English
64-bit (x64) Download (3.3 GB) Sha 1 hash — 1288519C5035BCAC83CBFA23A33038CCF5522749 32-bit (x86) Download (2.5 GB) Sha 1 hash — E91ED665B01A46F4344C36D9D88C8BF78E9A1B39 Product Key DNJXJ-7XBW8-2378T-X22TX-BKG7J
–jeroen
via: Windows 8 Consumer Preview ISO formats.
Posted in .NET, Development, Power User, Software Development, Visual Studio 11, Visual Studio and tools, Windows, Windows 8 | 2 Comments »
Posted by jpluimers on 2012/02/29
(Note the WordPress bug: you cannot have <Default> in a topic title, but having it in the text is fine, hence the [Default] in the title).
When porting some projects from .NET 1.x to .NET 4.x, I got these two errors:
Error 17 Type 'MyProject.My.MySettings' is not defined.
Error 18 'MyProject' is not a member of '<Default>'.
Both errors in the file ...\My Project\Settings.Designer.vb relative to the MyProject.vbproj file.
This was not the result of something like this Visual Studio 2005 bug, but of how the designer generated files are not being regenerated when you change the root namespace only in the MyProject.vbproj file, not through the IDE.
Steps to reproduce:
Lesson learned: when using text compare tools, some .vbproj changes should be propagated through the IDE, not through your favourite text compare tool.
When you change it in the IDE, it regenerates the *.Designer.vb files to reflect the changed namespace.
The solution is simple, in the IDE follow these steps:
–jeroen
via: type “my.mysettings” “is not defined.” – Google Search.
Posted in .NET, Development, Software Development, VB.NET | Leave a Comment »
Posted by jpluimers on 2012/02/28
I don’t do P/Invoke often, and somehow I have trouble remembering the value of CharSet to pass with DllImport.
In short, pass CharSet.Auto unless you P/Invoke a function that is specific to CharSet.Ansi or CharSet.Unicode. The default is CharSet.Ansi, which you usually don’t want:
when Char or String data is part of the equation, set the CharSet property to CharSet.Auto. This causes the CLR to use the appropriate character set based on the host OS. If you don’t explicitly set the CharSet property, then its default is CharSet.Ansi. This default is unfortunate because it negatively affects the performance of text parameter marshaling for interop calls made on Windows 2000, Windows XP, and Windows NT®.
The only time you should explicitly select a CharSet value of CharSet.Ansi or CharSet.Unicode, rather than going with CharSet.Auto, is when you are explicitly naming an exported function that is specific to one or the other of the two flavors of Win32 OS. An example of this is the ReadDirectoryChangesW API function, which exists only in Windows NT-based operating systems and supports Unicode only; in this case you should use CharSet.Unicode explicitly.
–jeroen
via: .NET Column: Calling Win32 DLLs in C# with P/Invoke.
Posted in .NET, Ansi, C#, Delphi, Development, Encoding, Prism, Software Development, Unicode | 3 Comments »
Posted by jpluimers on 2012/02/22
When handling SqlExceptions in C#, it is wise to assess the Class, as it indicates the severity.
Some classes are user error, others are fatal, etc.
This extension class will help you:
using System;
using System.Data.SqlClient;
namespace bo.MsSql
{
/// <summary>
/// see http://msdn.microsoft.com/en-us/library/ms164086.aspx
/// </summary>
public static class SqlExceptionSeverety
{
public static bool IsInformational(this SqlException sqlException)
{
return sqlException.Class < 10;
}
public static bool IsUserCorractable(this SqlException sqlException)
{
return (sqlException.Class >= 10) && (sqlException.Class < 17);
}
public static bool IsSoftwareError(this SqlException sqlException)
{
return (sqlException.Class >= 17) && (sqlException.Class < 20);
}
public static bool IsFatalSystemProblem(this SqlException sqlException)
{
return sqlException.Class >= 20;
}
}
}
–jeroen
Posted in .NET, C#, Development, Software Development | Leave a Comment »
Posted by jpluimers on 2012/02/17
Interesting:
JustDecompile is a new, free developer productivity tool for easy .NET assembly browsing and decompiling.
–jeroen
via: Free .NET Decompiler – JustDecompile.
Posted in .NET, C#, C# 2.0, C# 3.0, C# 4.0, Development, Software Development, VB.NET | Leave a Comment »
Posted by jpluimers on 2012/02/15
Recently the Android Design site was launched with great explanation on how to properly design UIs for Android Apps.
Like Apple’s iOS Human Interface Guidelines and Microsoft’s User Experience Design Guidelines for Windows Phone they are a must for any mobile developer.
Together with sites like Android UI Design Patterns, and mockup stencil tools, more Android UI mockup sketch tools and stencils allow you to give prospective users an impression on how an app might be looking like when developed.
What is lacking is a set of real Android GUI design tools. The kind of tools like the Xcode Interface Builder for iOS, or Expression Blend for Windows Phone that – together with iOS PSD templates or Windows Phone design templates (and more templates) – give you a killer start.
Also note Delphi XE2 that has a great UI designer which has consistently covered Windows UI design for 15+ years, including multi-touch and gesture support, and now covers Mac OS X and iOS for HD and 3D apps (but not yet with multi-touch or gesture support).
The only design tool for Android I could find is DroidDraw that emits the XML needed for Android UIs. It is painfully slow and lacks basic things like a property window to edit properties of UI elements.
Given the number of Android app developers, there is much room for improvement.
–jeroen
via: Android Design – UI Overview.
Posted in .NET, Android, Delphi, Development, iOS Development, Mobile Development, Software Development, Windows Phone Development | 6 Comments »
Posted by jpluimers on 2012/02/14
![What’s new in .NET Framework 4.5? [poster] (via Heikniemi Hardcoded)](https://i0.wp.com/www.heikniemi.net/hardcoded/wp-content/uploads/2011/10/WhatsNewNET45-en1.png "What’s new in .NET Framework 4.5? [poster] (via Heikniemi Hardcoded)")
I love the “Async ja Await equal to C#” in the picture and the copy-paste re-use in this blog entry from msguy.
Jouni Heikniemi originally posted “What’s new in .NET Framework 4.5 [poster]” on 20111029, then updated the poster on 20111116.
His original poster is Finnish, and his English poster contains a small translation glitch “Async ja Await equal to C#” (“ja” is Finnish for “and”).
Both posters are PNG filess, so msguy Anil made it into a textual document, including the translation glitch.
I love that, as it shows we are all humans :)
–jeroen
via: Bruno Leonardo Michels – Google+.
Posted in .NET, .NET 4.5, C# 2.0, C# 5.0, Software Development | 4 Comments »
Posted by jpluimers on 2012/01/26
This is WinForms code from a long time ago, but the concept of using an IDisposable interface to do resource cleanup and restore a temporary setting is very valid.
You use the code below like this:
private void myMethod()
{
// set busy cursor
using (IDisposable waitCursor = new TemporaryCursor(this, System.Windows.Forms.Cursors.WaitCursor))
{
// logic that takes a long while
}
}
The code below implements the TemporaryCursor class; you can assign any System.Windows.Forms.Cursors item you want.
It restores the cursor upon these three “events”:
Most often the IDispose pattern is being used to make sure that resources get cleaned up. If you think of a wait cursor as a temporary resource, this example becomes much easier to remember.
Of course this is not limited to the System.Windows.Forms realm, you can just as well use this for non-visual temporaries, and other kinds of UIs like ASP.NET, WPF or SilverLight.
using System.Windows.Forms;
namespace bo.Windows.Forms
{
public class TemporaryCursor : IDisposable
{
private Control targetControl;
private Cursor savedCursor;
private Cursor temporaryCursor;
private bool disposed = false;
public TemporaryCursor(Control targetControl, Cursor temporaryCursor)
{
if (null == targetControl)
throw new ArgumentNullException("targetControl");
if (null == temporaryCursor)
throw new ArgumentNullException("temporaryCursor");
this.targetControl = targetControl;
this.temporaryCursor = temporaryCursor;
savedCursor = targetControl.Cursor;
targetControl.Cursor = temporaryCursor;
targetControl.HandleDestroyed += new EventHandler(targetControl_HandleDestroyed);
}
void targetControl_HandleDestroyed(object sender, EventArgs e)
{
if (null != targetControl)
if (!targetControl.RecreatingHandle)
targetControl = null;
}
// public so you can call it on the class instance as well as through IDisposable
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (null != targetControl)
{
targetControl.HandleDestroyed -= new EventHandler(targetControl_HandleDestroyed);
if (temporaryCursor == targetControl.Cursor)
targetControl.Cursor = savedCursor;
targetControl = null;
}
disposed = true;
}
}
// Finalizer
~TemporaryCursor()
{
Dispose(false);
}
}
}
–jeroen
Posted in .NET, C#, C# 2.0, C# 3.0, C# 4.0, Development, Software Development, Visual Studio 2005, Visual Studio 2008, Visual Studio 2010, Visual Studio and tools, WinForms | 4 Comments »
Posted by jpluimers on 2012/01/25
A while ago, I needed to analyze a bunch of files based on the unique trimmed lines in them.
I based my code on the C# Tee filter and the StackOverflow example of C# deduping based on split.
It is a bit more extensive than strictly needed, as it has a few more commandline arguments that come in handy when processing files on the console:
DeDupe - Dedupes a file into unique lines (only the first occurance of a line is kept) standard output
Lines are terminated by CRLF sequences
C# implementation januari 5th, 2012 by Jeroen Wiert Pluimers (https://wiert.wordpress.com),
DeDupe [-i | --ignore] [-t | --trim] [-f | --flush] [-l | --literal] [-? | --h | --help | /?] [file0] [...]
Example:
DeDupe --trim file0.txt file1.txt
Dedupes the appended content of file0.txt and file1.txt into standard output
-t | --trim Will trim the lines before considering duplicates
-f | --flush Flushes files every CRLF
(setting is per tee instance)
-i | --ignore Ignore cancel Ctrl+C keypress: see UnixUtils tee
-l | --literal Stop recognizing flags, force all following filenames literally
-? | --h | /? | --help Displays this message and immediately quits
Duplicate filenames are quietly ignored.
If no input filenames are specified, then standard input is used
Press Ctrl+Z (End of File character) then Enter to abort.
Here is the source code:
using System;
using System.IO;
using System.Collections.Generic;
namespace DeDupe
{
class Program
{
static void help()
{
Console.Error.WriteLine("DeDupe - Dedupes a file into unique lines (only the first occurance of a line is kept) standard output");
Console.Error.WriteLine("Lines are terminated by CRLF sequences");
Console.Error.WriteLine("C# implementation januari 5th, 2012 by Jeroen Wiert Pluimers (https://wiert.wordpress.com),");
Console.Error.WriteLine("");
Console.Error.WriteLine("DeDupe [-i | --ignore] [-t | --trim] [-f | --flush] [-l | --literal] [-? | --h | --help | /?] [file0] [...]");
Console.Error.WriteLine(" Example:");
Console.Error.WriteLine(" DeDupe --trim file0.txt file1.txt");
Console.Error.WriteLine(" Dedupes the appended content of file0.txt and file1.txt into standard output");
Console.Error.WriteLine("");
Console.Error.WriteLine("-t | --trim Will trim the lines before considering duplicates");
Console.Error.WriteLine("-f | --flush Flushes files every CRLF");
Console.Error.WriteLine(" (setting is per tee instance)");
Console.Error.WriteLine("-i | --ignore Ignore cancel Ctrl+C keypress: see UnixUtils tee");
Console.Error.WriteLine("-l | --literal Stop recognizing flags, force all following filenames literally");
Console.Error.WriteLine("-? | --h | /? | --help Displays this message and immediately quits");
Console.Error.WriteLine("");
Console.Error.WriteLine("Duplicate filenames are quietly ignored.");
Console.Error.WriteLine("If no input filenames are specified, then standard input is used");
Console.Error.WriteLine("Press Ctrl+Z (End of File character) then Enter to abort.");
}
static void OnCancelKeyPressed(Object sender, ConsoleCancelEventArgs args)
{
// Set the Cancel property to true to prevent the process from
// terminating.
args.Cancel = true;
}
static List<String> filenames = new List<String>();
static void addFilename(string value)
{
if (-1 == filenames.IndexOf(value))
filenames.Add(value);
}
static bool trimLines = false;
static bool flushFiles = false;
static bool stopInterpretingFlags = false;
static bool ignoreCtrlC = false;
static int Main(string[] args)
{
try
{
foreach (string arg in args)
{
//Since we're already parsing.... might as well check for flags:
if (stopInterpretingFlags) //Stop interpreting flags, assume is filename
{
addFilename(arg);
}
else if (arg.Equals("/?") || arg.Equals("-?") || arg.Equals("-h") || arg.Equals("--help"))
{
help();
return 1; //Quit immediately
}
else if (arg.Equals("-t") || arg.Equals("--trim"))
{
trimLines = true;
}
else if (arg.Equals("-f") || arg.Equals("--flush"))
{
flushFiles = true;
}
else if (arg.Equals("-i") || arg.Equals("--ignore"))
{
ignoreCtrlC = true;
}
else if (arg.Equals("-l") || arg.Equals("--literal"))
{
stopInterpretingFlags = true;
}
else
{ //If it isn't any of the above, it's a filename
addFilename(arg);
}
//Add more flags as necessary, just remember to SKIP adding them to the file processing stream!
}
if (ignoreCtrlC) //Implement the Ctrl+C fix selectively (mirror UnixUtils tee behavior)
Console.CancelKeyPress += OnCancelKeyPressed;
HashSet<string> keys = new HashSet<string>();
Int64 index = 0;
using (StreamWriter writer = new StreamWriter(Console.OpenStandardOutput()))
{
if (filenames.Count == 0)
using (StreamReader reader = new StreamReader(Console.OpenStandardInput()))
{
processInputFileReader(keys, writer, reader, ref index);
}
else
foreach (String filename in filenames)
{
using (StreamReader reader = new StreamReader(filename))
{
processInputFileReader(keys, writer, reader, ref index);
}
}
writer.Flush();
}
}
catch (Exception ex)
{
Console.Error.WriteLine(String.Concat("DeDupe: ", ex.Message)); // Send error messages to stderr
}
return 0;
}
private static void processInputFileReader(HashSet<string> keys, StreamWriter writer, StreamReader reader, ref Int64 index)
{
string line = readLine(reader);
while (!string.IsNullOrEmpty(line))
{
string candidate = line;
if (keys.Add(candidate))
{
writer.WriteLine(line);
index += line.Length + Environment.NewLine.Length;
if (flushFiles)
writer.Flush();
}
line = readLine(reader);
}
}
private static string readLine(StreamReader reader)
{
string line = reader.ReadLine();
if (null != line)
if (trimLines)
line = line.Trim();
return line;
}
}
}
–jeroen
via: C# text file deduping based on split – Stack Overflow.
Posted in .NET, C#, C# 2.0, C# 3.0, C# 4.0, Development, Software Development | 4 Comments »
Posted by jpluimers on 2012/01/24
Every once in a while you need to maintain really old stuff, and start update an old VM.
In case of Visual Studio 2005, the Windows Update and Microsoft Update will get you into a condition where it cannot install “Security Update for Microsoft Visual Studio 2005 Service Pack 1 XML Editor (KB2251481)“. Not even the direct download will install.
The search for “some updates were not installed” “Security Update for Microsoft Visual Studio 2005 Service Pack 1 XML Editor (KB2251481)” pointed me to the solution:
There are two versions of KB2251481 June and August. When the June version is installed, the August version refuses to install.
Uninstall the original KB2251481 from the Control Panel. Then reinstall the August version.
The KB2251481 article mentions this only for the “Microsoft Visual Studio 2005 Premier Partner Edition SP1”, but it happens with other Visual Studio 2005 editions as well.
–jeroen
via: KB2251481 Security Update for Microsoft Visual Studio 2005 Service – Microsoft Answers.
Posted in .NET, Development, Software Development, Visual Studio 2005, Visual Studio and tools | 1 Comment »
The Wiert Corner - irregular stream of stuff 