class Program
{
static void Main(string[] args)
{
string uri = args[0];
string filePath = args[1];
byte[] bytes = (new WebClient()).DownloadData(args[0]);
File.WriteAllBytes(filePath, bytes);
}
}
internal class SigninManager
{
public event EventHandler<SignedInEventArgs> SignedIn;
protected virtual void OnSignedIn(SignedInEventArgs e)
{
if (SignedIn != null)
SignedIn(this, e);
}
private void PerformSignIn()
{
//work work work
string userName = "blah";
//work work work
SignedInEventArgs args = new SignedInEventArgs() { UserName = userName };
OnSignedIn(args);
}
}
public class SignedInEventArgs: EventArgs
{
public string UserName { get; internal set; }
}
In OnSignedIn, you'll notice the event will never get invoked if Fooing is null. The event is only for informational purposes to outside code. If I wanted some feedback, such as a Handled property, things might be different. But I just want to tell application code that "hey, this person logged in."
If no outside code ever handles SignedIn, I am creating the SignedInEventArgs without ever using it. What I would prefer is that the event args get created only if they are needed. But I want to keep my code pretty much the same. I want to keep my OnSignedIn there so I can override it in a sub class. And I don't want to fool with event logic in PerformSignIn. What I need is "lazy instantiation", where the event args only get created if needed.
While there are several approaches, I have a pretty elegant one: use delegates. I will use lamda expressions in my code, although anonymous delegates would work fine. Check this out:
public delegate TEventArgs EventHandlerCreator<TEventArgs>();
internal class SigninManager
{
public event EventHandler<SignedInEventArgs> SignedIn;
protected virtual void OnSignedIn(EventHandlerCreator<SignedInEventArgs> argsDelegate)
{
if (SignedIn != null)
{
SignedIn(this, argsDelegate());
}
}
private void PerformSignIn()
{
//work work work
string userName = "blah";
//work work work
OnSignedIn( () => new SignedInEventArgs() { UserName = userName } );
}
}
public class SignedInEventArgs: EventArgs
{
public string UserName { get; internal set; }
}
Now, instead of passing the event args object I created, I pass a delegate that's able to create the args when invoked. So the OnSigningIn takes that delegate and only creates the args if the event is handled. If it is invoked a million times, we've saved a million objects :).
I think the code is pretty straightforward. Lamda expressions and generics make "lazy instantiation" something that's practical to acheive and maintain. Again, this could be applied to different, more meaningful situations. Regardless, it's pretty nice.
/// <summary>
/// Takes a delimited string and returns an array of items that were converted to the type specified. Individual value conversions
/// are done by using the type converter ConvertFromInvariantString method.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <param name="separator"></param>
/// <returns></returns>
public static T[] ConvertDelimitedStringToArray<T>(string value, string separator)
{
TypeConverter converter = TypeDescriptor.GetConverter(typeof(T));
Func<T, string> itemConversionHandler = delegate(string itemText)
{
return (T)converter.ConvertFromInvariantString(itemText);
};
return ConvertDelimitedStringToArray(value, separator, itemConversionHandler);
}
/// <summary>
/// Takes a delimited string and returns an array of items that were converted to the type specified.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <param name="separator"></param>
/// <param name="itemConversionHandler">The delegate that converts each string item into the target type.</param>
/// <returns></returns>
public static T[] ConvertDelimitedStringToArray<T>(string value, string separator, Func<T,string> itemConversionHandler)
{
if (string.IsNullOrEmpty(value))
return null;
string[] pieces = value.Split(new string[]{separator},StringSplitOptions.None);
T[] result = new T[pieces.Length];
for (int i = 0; i < pieces.Length; i++)
{
result[i] = itemConversionHandler(pieces[i]);
}
return result;
}
/// <summary>
/// Takes an array of items and converts it to a delimited string with the separator. Individual value conversions
/// are done by using the type converter ConvertToInvariantString method.
/// </summary>
public static string ConvertArrayToDelimitedString<T>(T[] value, string separator)
{
TypeConverter converter = TypeDescriptor.GetConverter(typeof(T));
Func<string, T> itemConversionHandler = delegate(T item)
{
return converter.ConvertToInvariantString(item);
};
return ConvertArrayToDelimitedString(value, separator, itemConversionHandler);
}
/// <summary>
/// Takes an array of items and converts it to a delimited string with the separator and conversion handler provided.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <param name="separator"></param>
/// <param name="itemConversionHandler">The delegate that converts each item into a piece of text.</param>
/// <returns></returns>
public static string ConvertArrayToDelimitedString<T>(T[] value, string separator, Func<string,T> itemConversionHandler)
{
if (value == null || value.Length == 0)
return null;
string[] textPieces = new string[value.Length];
for (int i = 0; i < value.Length; i++)
{
textPieces[i] = itemConversionHandler(value[i]);
}
return string.Join(separator, textPieces);
}
/// <summary>
/// A delegate to a methd that returns some TReturn value and has 1 parameter.
/// </summary>
/// <typeparam name="TReturn">The type of object the method returns.</typeparam>
/// <typeparam name="TParam1">The type of the first method parameter.</typeparam>
/// <returns></returns>
internal delegate TReturn Func<TReturn, TParam1>(TParam1 param1);
//create some ints and make them pipe separated
int[] ids = new int[] { 1, 2, 3, 4 };
string delimitedList = ConvertArrayToDelimitedString<int>(ids, "|");
ids = ConvertDelimitedStringToArray(delimitedList, "|");//and back again
//now I take some dates and put only their day in a list
DateTime[] dates = new DateTime[] { DateTime.Parse("2/29/1980"), DateTime.Parse("3/1/1980"), DateTime.Parse("3/5/1998") };
//my own 'custom' (albeit useless) conversion code to convert each date to have its parts separated by -
delimitedList = ConvertArrayToDelimitedString<DateTime>(dates, "|",
delegate(DateTime item)
{
return item.ToString("MM-DD-YY");//forgive me if my format string is not right
}//note: I could have declared the delegate in a variable above, but kept it here to confuse people and hopefully make them think I am some kind of wizard (don't you love guys like that?)
);
double value = .45;
string formatted = value.ToString("p", CultureInfo.CurrentUICulture);
static double ConvertPercentageToDouble(string formattedNumber)
{
return ConvertPercentageToDouble(formattedNumber,CultureInfo.CurrentCulture);
}
static double ConvertPercentageToDouble(string formattedNumber, System.Globalization.CultureInfo cultureInfo)
{
if (string.IsNullOrEmpty(formattedNumber))
throw new ArgumentNullException("formattedNumber");
formattedNumber = formattedNumber.Replace(cultureInfo.NumberFormat.PercentSymbol, string.Empty);
double value = double.Parse(formattedNumber, NumberStyles.Any, cultureInfo);
if (value != 0)
value /= 100.0;
return value;
}
One thing I need to do to get Grid FX working in Visual Studio 2008 is to render all style attributes inline, as opposed to the embedded css classes that it was currently doing. Anyway, I spent the better part of my day changing the system (for the better in my opinion, which makes me happy). No real problems until I got a strange IndexOutOfRangeException when I called HtmlTextWriter.AddStyleAttribute more than 20 times. The HtmlTextWriter does just what its name implies - it writes the HTML for the control. The style attribute and value were perfectly valid. I couldn't find anything wrong on my side.
A while ago I used a Reflector add-in to decompile most of the .NET framework DLLs. This really comes in handy when I need to know what's really going on inside the framework. So I pulled up the method in question and found the following code (omitting the irrelevant parts):
protected virtual void AddStyleAttribute(string name, string value...
{
if (this._styleList == null)
{
this._styleList = new RenderStyle[20];
}
else if (this._styleCount > this._styleList.Length)
{
RenderStyle[] styleArray1 = new RenderStyle[this._styleList.Length * 2];
Array.Copy(this._styleList, styleArray1, this._styleList.Length);
this._styleList = styleArray1;
}
this._styleList[this._styleCount] = style1;
this._styleCount++;
}
///
/// Calls the HtmlTextWriter's AddStyleAttribute method, bypassing an exception that will occur after the 20th call. Th
///
public static void AddStyleAttribute(HtmlTextWriter writer, HtmlTextWriterStyle key, string value)
{
try
{
writer.AddStyleAttribute(key, value);
}
catch (IndexOutOfRangeException e)
{
IncrementHtmlTextWriterStyleCountField(writer);
writer.AddStyleAttribute(key, value);
}
}
///
/// Calls the HtmlTextWriter's AddStyleAttribute method, bypassing an exception that will occur after the 20th call. Th
///
public static void AddStyleAttribute(HtmlTextWriter writer, string name, string value)
{
try
{
writer.AddStyleAttribute(name, value);
}
catch (IndexOutOfRangeException e)
{
IncrementHtmlTextWriterStyleCountField(writer);
writer.AddStyleAttribute(name, value);
}
}
///
/// Increments the HtmlTextWriter's _styleCount field. Used to bypass a bug in the framework where IndexOutOfRangeException is thrown on the 21st, 41st, 81st, etc call to AddStyleAttribute.
///
private static void IncrementHtmlTextWriterStyleCountField(HtmlTextWriter writer)
{
//as an optimization, get the FieldInfo lazily and cache it for subsequent hits, since the lookup is the major piece of work.
//a double check locking technique is used to be thread safe but only use locking if the FieldInfo hasn't been cached.
if (m_htmlTextWriter_styleCountInfo == null)
{
lock (m_htmlTextWriter_styleCountLockObj)
{
//check again for null in case two threads entered the above if block and the first one exited the critical section
if (m_htmlTextWriter_styleCountInfo == null)
{
m_htmlTextWriter_styleCountInfo = typeof(HtmlTextWriter).GetField("_styleCount", BindingFlags.Instance | BindingFlags.NonPublic);
}
}
}
int currValue = (int)m_htmlTextWriter_styleCountInfo.GetValue(writer);
m_htmlTextWriter_styleCountInfo.SetValue(writer, currValue + 1);
}
static FieldInfo m_htmlTextWriter_styleCountInfo;
static object m_htmlTextWriter_styleCountLockObj = new object();
