Shimmy on .NET

WebClient that supports login and cookies

Shimmy — Wed, 19 Jun 2013 18:10:00 GMT

Hi, Here is a simple wrapper of WebClient that has an additional method Login, to allow for it to access and download user-only data, authenticated via a login-form post.

public class CookieAwareWebClient : WebClient
{
 
  public void Login(string loginPageAddress, NameValueCollection loginData)
  {
    CookieContainer container;
 
    var request = (HttpWebRequest)WebRequest.Create(loginPageAddress);
 
    request.Method = "POST";
    request.ContentType = "application/x-www-form-urlencoded";
    var buffer = Encoding.ASCII.GetBytes(loginData.ToString());
    request.ContentLength = buffer.Length;
    var requestStream = request.GetRequestStream();
    requestStream.Write(buffer, 0, buffer.Length);
    requestStream.Close();
 
    container = request.CookieContainer = new CookieContainer();
 
    var response = request.GetResponse();
    response.Close();
    CookieContainer = container;
  }
 
  public CookieAwareWebClient(string loginPageAddress, NameValueCollection loginData)
  {
    Login(loginPageAddress, loginData);
  }
 
  public CookieAwareWebClient(CookieContainer container)
  {
    CookieContainer = container;
  }
 
  public CookieAwareWebClient()
    : this(new CookieContainer())
  { }
 
  public CookieContainer CookieContainer { get; private set; }
 
  protected override WebRequest GetWebRequest(Uri address)
  {
    var request = (HttpWebRequest)base.GetWebRequest(address);
    request.CookieContainer = CookieContainer;
    return request;
  }
}

The usage is simple, call the Login method, and the login cookie will be set internally so the upcoming calls are authenticated:

static void Main()
{
  var loginPage = "www.site.com/login";
  var loginData = new NameValueCollection
  {
    { "username", "shimmy" },
    { "password", "mypassword" },
    { "rememberme", "1" }
  };
  var client = new CookieAwareWebClient(loginPage, loginData);
}

The Login method can be called after initialization as well.
The upcoming requests and downloads of the WebClient should all be authenticated.

Hope this helps,
Shimmy

Entity-Framework Code First Designer with Database Initialization in few simple steps!

Shimmy — Fri, 11 May 2012 10:49:00 GMT

I find it very frustrating that I cannot use the entity model designer to generate code-first DbContext & entities that retains all the aspects of code-first including database initialization.

Here are a set of instructions that can easily help you to achieve true code-first using the EDM designer, and allowing initialization of database (database initialization is not supported in model-first, it only allows generation of database scripts that has to be generated on the server).

This is very useful in small projects where you don't want to mess with the database, and you rather it being generated automatically.

In my example I chose to use SQL Compact Edition, but you can use SQL Express or other as well.

Right-click the project and select “Add New Item”

Select ADO.NET Entity Data Model, and rename the class if necessary

Choose “Empty Model” when asked

RIght-click the designer surface and click “Add Code Generation Item...”

From the left menu select “Online Templates” then under category “Database” choose EF 4.x DbContext Generator for C# (or different lang.)

Two new template files (*.tt) were generated to the project, open the Context.Context.tt file (the first ‘Context’ should be your model name)

Search for the constructor template, it calls the base constructor:
: base("name=<#=container.Name#>")
Remove the name= from it so it remains : base("<#=container.Name#>")

Erease or comment the OnModelCreating method

Add the following lines to your bootstrapper or App_Startup or any point where the application initializes:
AppDomain.CurrentDomain.SetData("DataDirectory", Environment.CurrentDirectory); Database.DefaultConnectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0"); Database.SetInitializer(new DropCreateDatabaseIfModelChanges<ContextContainer>());

If it's not a web application you're dealing with, you will need to set the DataDirectory variable of the generated connection string, see the first line above.

The second line sets the default connection factory which is the pipe Entity-Framework uses to generate a connection string (and hence a database), you can use either SqlCeConnectionFactory like in the above example, or SqlConnectionFactory and you can even create your own connection factory by implementing IDbConnectionFactory.

You can change the third line by setting the DatabaseInitializer to your own by deriving from the class above (you can use any class that implement IDatabaseInitializer), and override the Seed method, which allows you setting initial database values like deafult username/password etc.

Here is the sample project's execution, it will automatically generate an sdf database file that will be filled with data with no hassle of servers and all that. In fact you don't even care what the database schema looks like.
class Program { public static void Main(string[] args) { AppDomain.CurrentDomain.SetData("DataDirectory", Environment.CurrentDirectory); Database.DefaultConnectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0"); Database.SetInitializer(new DropCreateDatabaseIfModelChanges<ContextContainer>()); using (var context = new ContextContainer()) { context.Contacts.Add(new Contact { FirstName = "asdf" }); context.SaveChanges(); } } }

As you can see, it generated the database file to the project's folder, no database or schema mentioned at all.

Hope this helps, please comment on for questions.

Shimmy

After following the directions above, you can use the database

Get a list of all countries in C#

Shimmy — Fri, 11 May 2012 10:15:00 GMT

I'm sharing it here mostly for myself, but I hope someone else would also be able to enjoy it once...

static IEnumerable<Country> GetCountries()
{
  return from ri in
            from ci in CultureInfo.GetCultures(CultureTypes.SpecificCultures)
            select new RegionInfo(ci.LCID)
          group ri by ri.TwoLetterISORegionName into g
          //where g.Key.Length == 2
          select new Country
          {
            CountryId = g.Key,
            Title = g.First().DisplayName
          };
}
class Country
{
  public string CountryId { get; set; }
  public string Title { get; set; }
}

No ICloneable in WinRT?

Shimmy — Fri, 30 Mar 2012 05:57:00 GMT

Looks like the ICloneable interface has not been included in WinRT.

I could guess it's because of the uncertainty of whether the implentation is a shallow or a deep clone.

Would like to hear what you think about it.

Get Jewish date string

Shimmy — Sun, 04 Mar 2012 20:24:00 GMT

namespace System.Globalization
{
  public static class DateTimeExtensions
  {
    private const string HebrewCultureName = "he-IL";
    private static readonly CultureInfo HebrewCulture =
#if SILVERLIGHT
 new CultureInfo(HebrewCultureName);
#else
 CultureInfo.CreateSpecificCulture(HebrewCultureName);
#endif
    /// <summary>
    /// Converts a gregorian date to its hebrew date string representation,
    /// using custom DateTime format string.
    /// </summary>
    /// <param name="value">The <see cref="DateTime"/> value to convert.</param>
    /// <param name="format">A standard or custom date and time format string.</param>
    public static string ToJewishDateString(this DateTime value, string format)
    {
      HebrewCulture.DateTimeFormat.Calendar = new HebrewCalendar();
      return value.ToString(format, HebrewCulture);
    }
 
    /// <summary>
    /// Converts a gregorian date to its hebrew date string representation,
    /// using DateTime format options.
    /// </summary>
    /// <param name="value">The <see cref="DateTime"/> value to convert.</param>
    /// <param name="dayOfWeek">Specifies whether the return string should
    /// include the day of week.</param>
    public static string ToJewishDateString(this DateTime value, bool dayOfWeek)
    {
      var format = dayOfWeek ? "D" : "d";
      return value.ToJewishDateString(format);
    }
  }
}

Determine if char is Hebrew (2)

Shimmy — Fri, 03 Feb 2012 07:52:00 GMT

About 2 weeks ago I posted a function that determines whether a given char is hebrew:

// avoid unicode chars in code
private const char FirstHebChar = (char)1488; //א
private const char LastHebChar = (char)1514; //ת
private static bool IsHebrew(this char c)
{
  return c >= FirstHebChar && c <= LastHebChar;
}

Schabse Laks commented that it won't include punctuation marks / vowels etc.

This week I needed a more sophisticated function that does the job, so I ended up with the extension methods bellow (view raw code here).
Note, that I needed the function for a one-time-use application so I didn't optimize the code well enough, any improvements will be welcomed as always, and especially now.

namespace System
{
  using System.Linq;
  using System.Collections.Generic;
 
  public static class HebrewCharsExtensions
  {
    public static bool IsHebrew(this char c)
    {
      return IsHebrew(c, HebrewCharTypes.All);
    }
 
    public static bool IsHebrew(this char c, HebrewCharTypes charTypes)
    {
      foreach (var kv in Map.Where(ct => charTypes.HasFlag(ct.Key)))
      {
        var locMap = kv.Value;
        for (int i = 0; i <= locMap.GetUpperBound(0); i++)
          if (c >= locMap[i, 0] && c <= locMap[i, 1]) return true;
      }
      return false;
    }
 
    public static HebrewCharTypes GetHebrewCharType(this char c)
    {
      foreach (var kv in Map)
      {
        var locMap = kv.Value;
        for (int i = 0; i <= locMap.GetUpperBound(0); i++)
          if (c >= locMap[i, 0] && c <= locMap[i, 1]) return kv.Key;
      }
      return HebrewCharTypes.None;
    }
 
    public static IEnumerable<char> GetHebChars()
    {
      return GetHebChars(HebrewCharTypes.All);
    }
 
    public static IEnumerable<char> GetHebChars(HebrewCharTypes charTypes)
    {
      foreach (var kv in Map.Where(ct => charTypes.HasFlag(ct.Key)))
      {
        var locMap = kv.Value;
        for (int i = 0; i <= locMap.GetUpperBound(0); i++)
        {
          var start = locMap[i, 0];
          var end = locMap[i, 1];
          foreach (var ch in Enumerable.Range(start, end - start + 1))
            yield return (char)ch;
        }
      }
    }
 
    private static readonly Dictionary<HebrewCharTypes, int[,]> Map = new Dictionary<HebrewCharTypes, int[,]>
    {
       {HebrewCharTypes.Letter,   new int[,] { { 0x05d0, 0x05ea } } },
       {HebrewCharTypes.Vowel,    new int[,] { { 0x05b0, 0x05b9 }, { 0x05bb, 0x05c4 }, { 0xfb2a, 0xfb36 }, { 0xfb38, 0xfb3c }, { 0xfb3e, 0xfb3e }, { 0xfb40, 0xfb41 }, { 0xfb43, 0xfb44 }, { 0xfb46, 0xfb4e} } },
       {HebrewCharTypes.Biblical, new int[,] { { 0x0591, 0x05a1 }, { 0x05a3, 0x05af }, { 0xfb1e, 0xfb1e }, { 0xfb4f, 0xfb4f } } },
       {HebrewCharTypes.Yiddish,  new int[,] { { 0x05f0, 0x05f2 }, { 0xfb1f, 0xfb1f } } },
       {HebrewCharTypes.Special,  new int[,] { { 0x05f3, 0x05f4 }, { 0xfb20, 0xfb29 } } }
    };
 
  }
 
  [Flags]
  public enum HebrewCharTypes
  {
    /// <summary>
    /// Not a Hebrew character.
    /// </summary>
    None = 0,
    /// <summary>
    /// Alef to Tav.
    /// </summary>
    Letter = 1,
    /// <summary>
    /// Qamats to Hataf Segol.
    /// </summary>
    Vowel = 2,
    /// <summary>
    /// Kadma Munah Pashta etc.
    /// </summary>
    Biblical = 4,
    /// <summary>
    /// Double Yod etc.
    /// </summary>
    Yiddish = 8,
    /// <summary>
    /// Other special characters (wide chars and more).
    /// </summary>
    Special = 16,
    All = Letter | Vowel | Biblical | Yiddish | Special
  }
}

LeakEvent → WeakEvent

Shimmy — Wed, 01 Feb 2012 20:53:00 GMT

I'm sure not any Silverlight developer is aware of the fact that when one subscribes to an event, a strong reference to the handler class ('target') is attached to the event source ('source'), hence, if the source object life-cycle is longer than the target, memory is leaked, becuase when you don't need the target anymore and all its references are removed, there is still one reference to it by that event handler in the source, and thus, won't get collected by GC.

A strong reference is a normal reference that protects the referred object from collection by a garbage collector. The term is used to distinguish the reference from weak references.

If you're using Silverlight you must have encountered this scenario before.
Here is a typical scenaio: you have long running object publishing events and a temporary view model that handles its events, once you subscribe to an event of the long-running object, you may never get rid of the view-model until that object itself is GCed.
Say you have a LoginViewModel that subscribes to WebContext.Authentication.LoggedIn event (WCF RIA) within your view model, when your view-model is supposed to go out-of-scope, it won't be eligible for GC since the LoggedIn event source holds a reference to it! This is just an example that its impact might be low considering the LoginViewModel and its resources (no memory leak is ever considerable at all but anyway), if we're talking about a utility that holds heavyweight info and subscribes to events published by a long-living object without letting the GC collecting itself (by weakly subscribing to that event) is a terrible memory leak.

To solve this problem, Microsoft provides the WeakReference wrapper which is used as a proxy to an object, and references an object while still allowing that object to be reclaimed by garbage collection.

Unlike in Silverlight, other platforms (i.e. WPF) have out-the-box support for weak events, however, those helpers are not shipped with Silverlight.
Another issue is, invoking a private method by reflection is restricted in Silverlight, and that's why the provided WeakHandler class bellow doesn't take a method for self maintenance.

I won't repeat the basics, I will just refer you to an awsome article written long time ago, that goes in detail of this issue, and actually influenced my code as well.
I expanded the code in the article to overcome the private method invoking restriction, so the 'target' has to implement a handler method, then all you have to do is remove the handle at destruction (will reach destructor since we use a weak-reference that will allow GCing the target.

I named it WeakHandler to keep it simple, here is what the class looks like (usage bellow):

namespace System
{
 
  /// <summary>
  /// Encapsulates an event publisher and a handler while still allowing the objects to be garbage collected.
  /// </summary>
  /// <typeparam name="TTarget">The type of the class that declares the handler.</typeparam>
  /// <typeparam name="TEventArgs">The type of <see cref="EventArgs"/> this event handler accepts as an argument.</typeparam>
  public class WeakHandler<TTarget, TEventArgs>
    where TTarget : class, IWeakHandler<TEventArgs>
    where TEventArgs : EventArgs
  {
 
    private WeakReference _target;
 
    /// <summary>
    /// Initializes a new object of <see cref="WeakHandler"/>.
    /// </summary>
    /// <param name="target">The object that handles the event.</param>
    public WeakHandler(TTarget target)
    {
      if (target == null) throw new ArgumentNullException("target");
 
      _target = new WeakReference(target);
    }
 
    /// <summary>
    /// The method that should actually be subscribed to the event.
    /// </summary>
    /// <param name="sender">The object that publishes the event.</param>
    /// <param name="e">The <see cref="EventArgs"/> to be passed to the event handler.</param>
    public virtual void OnEventRaised(object sender, TEventArgs e)
    {
      if (Target != null)
        Target.OnEventRaised(sender, e);
    }
 
    /// <summary>
    /// The object that handles the event.
    /// </summary>
    public TTarget Target
    {
      get
      {
        return (TTarget)_target.Target;
      }
    }
 
    //An empty destructor costs performance (see this for detail: http://msdn.microsoft.com/en-us/library/66x5fx1b.aspx)!
#if DEBUG
    //Will Validate our test:
    ~WeakHandler()
    {

      System.Diagnostics.Debug.WriteLine("WeakHandler finalized.");
    }
#endif
  }

  /// <summary>
  /// Defines an event handler of the specified <see cref="EventArgs"/>. 
  /// </summary>
  /// <typeparam name="TEventArgs">The <see cref="EventArgs"/> type of this event.</typeparam>
  public interface IWeakHandler<TEventArgs>
  where TEventArgs : EventArgs
  {
    /// <summary>
    /// The method to be raised when the event is fired.
    /// </summary>
    /// <param name="sender">The object that raised the event.</param>
    /// <param name="e">The <see cref="EventArgs"/> of the event.</param>
    void OnEventRaised(object sender, TEventArgs e);
  }

Usage:

public partial class App : Application
{
 
  public App()
  {
    InitializeComponent();
    Startup += Current_Startup;
  }
 
  void Current_Startup(object sender, StartupEventArgs e)
  {
    Source source = new Source();
    Target target = new Target(source);
    source.RaiseEvent();
    target = null;
 
    Debug.WriteLine("Collecting Target.");
    GC.Collect();
    GC.WaitForPendingFinalizers();
 
    Debug.WriteLine("Recollecting to clean weak handler.");
    GC.Collect();
    GC.WaitForPendingFinalizers();
 
    source.RaiseEvent();
    source = null;
 
    Debug.WriteLine("Collecting Source.");
    GC.Collect();
    GC.WaitForPendingFinalizers();
 
    /*
    Output:
      Raising event.
      Event raised.
      Collecting Target.
      Finalizing Target.
      Target finalized.
      Recollecting to clean weak handler.
      WeakHandler finalized.
      Raising event.
      Collecting Source.
      Source finalized.
      */
  }
}
 
public class Target : IWeakHandler<EventArgs>
{
  WeakHandler<Target, EventArgs> weakHandler;
 
  public Target(Source source)
  {
    _Source = source;
    weakHandler = new WeakHandler<Target, EventArgs>(this);
    Source.Event += weakHandler.OnEventRaised;
  }
 
  private readonly Source _Source;
  public Source Source
  {
    get
    {
      return _Source;
    }
  }
 
  public void OnEventRaised(object sender, EventArgs e)
  {
    Debug.WriteLine("Event raised.");
  }
 
  ~Target()
  {
    Debug.WriteLine("Finalizing Target.");
    //Omitting the following line will cause the WeakHandler to have a life-time as the source.
    //Although the WeakHandler is just a body-class that holds nothing
    //(remember that target is weak-referenced hence can be garbage collected).
    Source.Event -= weakHandler.OnEventRaised;
    Debug.WriteLine("Target finalized.");
  }
}
 
public class Source
{
  public event EventHandler Event;
 
  public void RaiseEvent()
  {
    Debug.WriteLine("Raising event.");
    if (Event != null) Event(this, EventArgs.Empty);
  }
 
  ~Source()
  {
    Debug.WriteLine("Source finalized.");
  }
}

You can download the source code from here, or the DLL from here.

Any comments, improvements, or if you just like to shout out for fun, anything will be welcomed!

HTH,
Shimmy

Congratulations! We had a new babygirl!

Shimmy — Mon, 23 Jan 2012 09:03:00 GMT

Hi everyone!

We just a had a very cute babygirl!

Hope to post some photo any time soon...

UniqueAttribute that validates a unique field against its fellow rows in the database (inherits DataAnnotations.ValidationAttribute)

Shimmy — Mon, 23 Jan 2012 09:00:00 GMT

UPDATE: Jan 30 2012: Added check that entity is not itself (i.e. when user attempts to save the same entity).
UPDATE: Feb 26 2012: Added support for inherited entities, where the validated property is on the sub-class of the inheritance hierarchy.

Here is a ValidationAttribute subclass that will allow you to validate that a column doesn't have duplicates.

It's intended to be used with EF 4.1 DbContext, or with the EF4's ObjectContext.

namespace System.ComponentModel.DataAnnotations
{
#if !SILVERLIGHT
  using System;
  using System.Data.Entity;
  using System.Data.Entity.Infrastructure;
  using System.Data.Metadata.Edm;
  using System.Data.Objects;
  using System.Linq;
#endif 
  /// <summary>
  /// Validates whether a value is set in another row at the same column.
  /// Does not validate null empty or whitespace strings.
  /// </summary>
  [AttributeUsage(AttributeTargets.Property)]
  public class UniqueAttribute : ValidationAttribute
  {
 
#if SILVERLIGHT   
    /// <summary>
    /// Just a body method, the ValidationAttribute requires the IsValid method to be overridden.
    /// </summary>
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
      return ValidationResult.Success;
    }
#else
    private readonly Type _ContextType;
    public Type ContextType
    {
      get
      {
        return _ContextType;
      }
    }
 
 
    //TODO: If placed in your domain, uncomment and replace MyDbContext with your domain's DbContext/ObjectContext class.
    //public UniqueAttribute() : this(typeof(MyDbContext)) { }
 
 
    /// <summary>
    /// Initializes a new instance of <see cref="UniqueAttribute"/>.
    /// </summary>
    /// <param name="contextType">The type of <see cref="DbContext"/> or <see cref="ObjectContext"/> subclass that will be used to search for duplicates.</param>
    public UniqueAttribute(Type contextType)
    {
      if (contextType == null)
        throw new ArgumentNullException("contextType");
      if (!contextType.IsSubclassOf(typeof(DbContext)) && !contextType.IsSubclassOf(typeof(ObjectContext)))
        throw new ArgumentException("The contextType Type must be a subclass of DbContext or ObjectContext.", "contextType");
      if (contextType.GetConstructor(Type.EmptyTypes) == null)
        throw new ArgumentException("The contextType type must declare a public parameterless consructor.");
 
      _ContextType = contextType;
    }
 
 
    /// <summary>
    /// Validates the value against the matching columns in the other rows of this table.
    /// Note that this method does not validate null or empty strings.
    /// </summary>
    /// <param name="value">The value to validate</param>
    /// <param name="validationContext">The context information about the validation operation.</param>
    /// <returns>An instance of the <see cref="ValidationResult"/> class.</returns>
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
      if (value == null || (value is string && string.IsNullOrWhiteSpace((string)value))) return ValidationResult.Success;
 
      var type = validationContext.ObjectType;
      var property = type.GetProperty(validationContext.MemberName);
      type = property.DeclaringType;
 
      using (var dbcontext = (IDisposable)Activator.CreateInstance(_ContextType))
      {
        var context = dbcontext is DbContext ? ((IObjectContextAdapter)dbcontext).ObjectContext : (ObjectContext)dbcontext;
        var md = context.MetadataWorkspace;
        var entityType = md.GetItems<EntityType>(DataSpace.CSpace).SingleOrDefault(et => et.Name == type.Name);
 
        while (entityType.BaseType != null)
          entityType = (EntityType)entityType.BaseType;
 
        var objectType = typeof(object);
        var isInherited = false;
        var baseType = type;
        while (baseType.Name != entityType.Name && baseType.BaseType != objectType)
        {
          baseType = baseType.BaseType;
          isInherited = true;
        }
 
        var methodCreateObjectSet = typeof(ObjectContext).GetMethod("CreateObjectSet", Type.EmptyTypes).MakeGenericMethod(baseType);
        var baseObjectSet = (ObjectQuery)methodCreateObjectSet.Invoke(context, new object[] { });
        var objectSet = baseObjectSet;
        var setType = baseObjectSet.GetType();
 
        if (isInherited)
        {
          var ofType = setType.GetMethod("OfType");
          ofType = ofType.MakeGenericMethod(type);
          objectSet = (ObjectQuery)ofType.Invoke(baseObjectSet, null);
          setType = objectSet.GetType();
        }
 
        var methodWhere = setType.GetMethod("Where");
 
        var eSql = string.Format("it.{0} = @{0}", validationContext.MemberName);
 
        var query = (ObjectQuery)methodWhere.Invoke(objectSet,
          new object[] { eSql, new[] { new ObjectParameter(validationContext.MemberName, value) } });
 
        var result = query.Execute(MergeOption.NoTracking).Cast<object>();
 
        bool isValid = true;
        using (var enumerator = result.GetEnumerator())
        {
          if (enumerator.MoveNext())
          {
            var nameProperty = typeof(ObjectSet<>).MakeGenericType(baseType).GetProperty("EntitySet");
            var entitySet = (EntitySet)nameProperty.GetValue(baseObjectSet, null);
            var entitySetName = entitySet.Name;
 
            do
            {
              var current = enumerator.Current;
              var curKey = context.CreateEntityKey(entitySetName, current);
              var validatingKey = context.CreateEntityKey(entitySetName, validationContext.ObjectInstance);
 
              if (curKey != validatingKey)
              {
                isValid = false;
                break;
              }
            } while (enumerator.MoveNext());
          }
        }
 
        return isValid ?
          ValidationResult.Success :
          new ValidationResult(
            string.Format("There is already a '{0}' record that has its '{1}' field set to '{2}'.",
              validationContext.ObjectType.Name,
              validationContext.DisplayName,
              value),
            new[] { validationContext.MemberName });
      }
    }
#endif
  }
}

As soon as you will be trying to call DbContext.SaveChanges in the DomainService, if one of the entities is invalidated by this attribute, the save will fail.
Since I didn't test this attribute in the LinqToEntitiesDomainService, I'm affraid that since the ObjectContext doesn't validate entities when submitting changes, you'll have to make a use of the ValidationContext property, please comment if anything is unclear or for further details.
This attribute should work just like all the other ValidationAttributes do.

When using with a Silverlight project and a WCF-RIA service, as soon as you'll try to commit the changes, it will stop and is reported back to the client who has its DataField decorated with the validation error, and since the DomainContext.SubmitChanges in the client is asynchronous, all this will happen asynchronously.

To view raw code please refer here.

Since I didn't invest in testing it in other environments (For instance SL < 5.0) and other test options/features, any comments/improvements will be very appreciated.

What's not implemented is, selecting just the ID column and the duplicate-check column. I was too lazy to invest on building the select column (getting the ID column(s) of a specific entity).
Anyway, depending on the column amount of the table, it shouldn't make such a huge difference, as this query is not supposed to return more than one row anyway, unless bypassed this validation by adding rows directly to database.

Hope this helps,
Shimmy

Determine if char is Hebrew

Shimmy — Thu, 19 Jan 2012 05:38:00 GMT

Simple Ex. method:

// avoid unicode chars in code
private const char FirstHebChar = (char)1488; //א
private const char LastHebChar = (char)1514; //ת 
private static bool IsHebrew(this char c)
{
  return c >= FirstHebChar && c <= LastHebChar;
}

Note: a comment bellow noted that the above function solely checks for hebrew characters within the א-ת range,
it won't include punctuation marks, vowels or other biblical symbols.

For a function that covers all (all that I'm aware of) Hebrew characters, please refer here.

Enum.IsDefined for combined values not declared in the enum body

Shimmy — Thu, 12 Jan 2012 08:32:00 GMT

When you try to determine if an Enum value is defined in an Enum, it returns true only if the flags you've combined are explicitly declared in the Enum.

Consider this Enum:

[Flags]// Enum defined with a FlagsAttribute attribute.
enum Hue : sbyte
{
  Black = 0, //no color
  Red = 1,
  Green = 2,
  Blue = 4,
  Cyan = Green | Blue,//6
  Magenta = Red | Blue,//5
  BadColor = 127
}

The following line will return false:

var white = Hue.Red | Hue.Blue | Hue.Green; //7

Even tho theoretically the enum combination is valid.

So to make sure a value doesn't exceed the enums limit, but is not necessarily declared, we can use the following function:

(You can cashe the Enum.GetValues to improve performance)

public static bool IsDefined(this Enum value)
{
  dynamic dyn = value;
  var max = Enum.GetValues(value.GetType()).Cast<dynamic>().
    Aggregate((e1, e2) => e1 | e2);
  return (max & dyn) == dyn;
}

The above function will solve the problem:

    static void Main(string[] args)
    {
      var white = Hue.Red | Hue.Blue | Hue.Green; //7
      var isDef1 = Enum.IsDefined(typeof(Enum), white); //false
      var isDef2 = white.IsDefined(); //true
    }

Note: Performance not tested at all.

Close window from ViewModel

Shimmy — Wed, 05 Oct 2011 07:57:00 GMT

Although this is somewhat corny, I will dedicate for it a post. Scenario: you want to close a window from the ViewModel, without exposing the Window to it. This can be done in a simple and clean way.
(Some code removed for brevity)

HTH,
Shimmy

XAML:

<Window
  x:Name="this"
  xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"  
  xmlns:ei="http://schemas.microsoft.com/expression/2010/interactions">
  <i:Interaction.Triggers>
    <i:EventTrigger SourceObject="{Binding}" EventName="Closed">
      <ei:CallMethodAction
        TargetObject="{Binding ElementName=this}"
        MethodName="Close"/>
    </i:EventTrigger>
  </i:Interaction.Triggers>
<Window>

Code (from the ViewModel - DelegateCommand refers to the one of Prism's library, but it's the same idea of RelayCommand etc.):

private ICommand _SaveAndCloseCommand;
public ICommand SaveAndCloseCommand
{
  get
  {
    return _SaveAndCloseCommand ??
      (_SaveAndCloseCommand = new DelegateCommand(SaveAndClose));
  }
}
private void SaveAndClose()
{
  Save();
  Close();
}
 
public event EventHandler Closed;
private void Close()
{
  if (Closed != null) Closed(this, EventArgs.Empty);
}

TIP: Silverlight 5 Beta IMarkupExtension and StaticExtension

Shimmy — Tue, 17 May 2011 04:30:00 GMT

In WPF, there is the well known StaticExtension. However Silverlight users are struggling in finding quirky workarounds to this missing feature.

Now, in Silverlight 5, Microsoft introduced the IMarkupExtension<T> interface.
This one, not only reflects to the WPF MarkupExtension, but also is a generic interface rather than a class.
The MarkupExtension abstract class features only one method ProvideValue, this is a huge disadvantage, since you cannot inherit from multiple classes, and if you ever wanted to combine the MarkupExtension with another class (i.e. DependencyObject so you can set its properties with Data-Binding), this was impossible, whereas a type can implement multiple interfaces.

So let's see some code.

XAML (m: refers to the namespace of the StaticExtension):

  <ContentControl                                                                                                                                 
    prism:RegionManager.RegionName="{Binding Source={m:Static MemberType=vm:RegionNames, Member=MainContent}}" />

C#:

using System.Xaml;
using System.ComponentModel;
using System.Globalization;
using System.Reflection;
 
namespace System.Windows.Markup
{
  /// <summary>
  /// Implements a markup extension that returns static field and property references.
  /// </summary>
  public class StaticExtension : MarkupExtension
  {
    // Fields
    private string _member;
    private Type _memberType;
 
    /// <summary>
    /// Initializes a new instance of the <see cref="System.Windows.Markup.StaticExtension"/> class.
    /// </summary>
    public StaticExtension()
    {
    }
 
    /// <summary>
    /// Initializes a new instance of the <see cref="System.Windows.Markup.StaticExtension"/> class
    /// using the provided member string.
    /// </summary>
    /// <param name="member">A string that identifies the member to make a reference to.
    /// This string uses the format prefix:typeName.fieldOrPropertyName. prefix is the mapping prefix for a XAML namespace,
    /// and is only required to reference static values that are not mapped to the default XAML namespace.</param>
    /// <exception cref="System.ArgumentNullException"><paramref name="member"/> is null.</exception>
    public StaticExtension(string member)
    {
      if (member == null)
      {
        throw new ArgumentNullException("member");
      }
      this._member = member;
    }
 
    private bool GetFieldOrPropertyValue(Type type, string name, out object value)
    {
      FieldInfo field = null;
      Type baseType = type;
      do
      {
        field = baseType.GetField(name, BindingFlags.Public | BindingFlags.Static);
        if (field != null)
        {
          value = field.GetValue(null);
          return true;
        }
        baseType = baseType.BaseType;
      }
      while (baseType != null);
      PropertyInfo property = null;
      baseType = type;
      do
      {
        property = baseType.GetProperty(name, BindingFlags.Public | BindingFlags.Static);
        if (property != null)
        {
          value = property.GetValue(null, null);
          return true;
        }
        baseType = baseType.BaseType;
      }
      while (baseType != null);
      value = null;
      return false;
    }
 
    /// <summary>
    /// Returns an object value to set on the property where you apply this extension.
    /// For <see cref="System.Windows.Markup.StaticExtension"/>,
    /// the return value is the static value that is evaluated for the requested static member.
    /// </summary>
    /// <param name="serviceProvider">An object that can provide services for the markup extension.
    /// The service provider is expected to provide a service that implements a type resolver
    /// (<see cref="System.Windows.Markup.IXamlTypeResolver"/>).</param>
    /// <returns>The static value to set on the property where the extension is applied.</returns>
    /// <exception cref="System.InvalidOperationException">The member value for the extension
    /// is null at the time of evaluation.</exception>
    /// <exception cref="System.ArgumentException">Some part of the member string did not parse properly
    /// -or- <paramref name="serviceProvider"/> did not provide a service for <see cref="System.Windows.Markup.IXamlTypeResolver"/>
    /// -or- member value did not resolve to a static member.</exception>
    /// <exception cref="System.ArgumentNullException"><paramref name="serviceProvider"/> is null.</exception>
    public override object ProvideValue(IServiceProvider serviceProvider)
    {
      object obj2;
      if (this._member == null)
      {
        throw new InvalidOperationException("StaticExtension must have Member property set before ProvideValue can be called.");
      }
      Type memberType = this.MemberType;
      string str = null;
      string str2 = null;
      if (memberType != null)
      {
        str = this._member;
        str2 = memberType.FullName + "." + this._member;
      }
      else
      {
        str2 = this._member;
        int index = this._member.IndexOf('.');
        if (index < 0)
        {
          throw new ArgumentException(string.Format(
            "'{0}' StaticExtension value cannot be resolved to an enumeration, static field, or static property.", this._member));
        }
        string qualifiedTypeName = this._member.Substring(0, index);
        if (qualifiedTypeName == string.Empty)
        {
          throw new ArgumentException(string.Format(
            "'{0}' StaticExtension value cannot be resolved to an enumeration, static field, or static property.", this._member));
        }
        if (serviceProvider == null)
        {
          throw new ArgumentNullException("serviceProvider");
        }
        IXamlTypeResolver service = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
        if (service == null)
        {
          throw new ArgumentException(string.Format(
            "Markup extension '{0}' requires '{1}' be implemented in the IServiceProvider for ProvideValue.",
            base.GetType().Name,
            "IXamlTypeResolver"));
        }
        memberType = service.Resolve(qualifiedTypeName);
        str = this._member.Substring(index + 1, (this._member.Length - index) - 1);
        if (str == string.Empty)
        {
          throw new ArgumentException(string.Format(
            "'{0}' StaticExtension value cannot be resolved to an enumeration, static field, or static property.", this._member));
        }
      }
      if (memberType.IsEnum)
      {
        return Enum.Parse(memberType, str, false);
      }
      if (!this.GetFieldOrPropertyValue(memberType, str, out obj2))
      {
        throw new ArgumentException(string.Format(
          "'{0}' StaticExtension value cannot be resolved to an enumeration, static field, or static property.", str2));
      }
      return obj2;
    }
 
 
    /// <summary>
    /// Gets or sets a member name string that is used to resolve a static field or property
    /// based on the service-provided type resolver.
    /// </summary>
    /// <returns>A <see cref="System.String"/> that identifies the member to make a reference to.</returns>
    /// <exception cref="System.ArgumentNullException">Attempted to set
    /// <see cref="System.Windows.Markup.StaticExtension.Member"/> to null.</exception>    
    public string Member
    {
      get { return this._member; }
      set
      {
        if (value == null)
          throw new ArgumentNullException("value");
        this._member = value;
      }
    }
 
    /// <summary>
    /// Gets or sets the <see cref="System.Type"/> that defines the static member to return.
    /// </summary>
    /// <returns>The <see cref="System.Type"/> that defines the static member to return.</returns>
    /// <exception cref="ArgumentNullException">Attempted to set
    /// <see cref="System.Windows.Markup.StaticExtension.MemberType"/> to null.</exception>
    [DefaultValue((string)null)]
    public Type MemberType
    {
      get { return this._memberType; }
      set
      {
        if (value == null)
          throw new ArgumentNullException("value");
        this._memberType = value;
      }
    }
  }
}

TIP: Dictionary - Use generic type argument as keys

Shimmy — Mon, 09 May 2011 10:25:00 GMT

When you want to store items by known types using the type as the key, you could add some methods to the Dictionary<,> class to make this work the generic way.

It basically does nothing but does the typeof(MyType) for you.

Note: Didn't test performance impacts.

using System.Collections.Generic;

namespace System.Collections.Specialized
{
  public class TypeDictionary<TValue> : Dictionary<Type, TValue>
  {
    public TValue Get<T>()
    {
      return this[typeof(T)];
    }

    public void Add<T>(TValue value)
    {
      Add(typeof(T), value);
    }

    public bool Remove<T>()
    {
      return Remove(typeof(T));
    }

    public bool TryGetValue<T>(out TValue value)
    {
      return TryGetValue(typeof(T), out value);
    }

    public bool ContainsKey<T>()
    {
      return ContainsKey(typeof(T));
    }
  }
}

This time I have a certificate too!

Tip: Casting in C# shortcut extension method

Shimmy — Wed, 06 Apr 2011 22:24:00 GMT

The C# cast operator (Type)value is pretty verbose.
When you work with COM, extenal APIs, DataSets or other not well-OOPed infrastractures, you often get an expected type as object (i.e. you know the runtime-type of the variable is string, but it's object at compile-time).

Here is an example of many castings in one-line:

IEntity entity = (IEntity)GetObjectById("Customer", 34);
string name = (string)entity.GetField("Name");
int length = name.Length;

Or as a one-liner, you really get confused with the parenthesis:

int len = ((string)((IEntity)GetObjectById("Customer", 34)).GetField("Name")).Length;

With this extension you can make the code a bit more readable:

IEntity entity = GetObjectById("Customer", 34).As<IEntity>();
string name = entity.GetField("Name").As<string>();
int length = name.Length;
 
int len = GetObjectById("Customer", 34).As<IEntity>().
  GetField("Name").As<string>().
  Length;

Here is the extension:

/// <summary>
/// Directly casts an object to a desired type.
/// </summary>
public static T As<T>(this object value)
{
  return (T)value;
}

There is actually nothing sophisticated in this, and cost much more performance (calling an extension method).
But is useful for certain scenarios.

A short performance test shws that using the cast operator is about as twice as faster than the function:

static void Main(string[] args)
{
  Stopwatch watch = Stopwatch.StartNew();
  for (int i = 0; i < 10000000; i++)
  {
    object myInt = 34;
    int theInt = myInt.As<int>();
  }
  watch.Stop();
  long elapsedAs = watch.ElapsedTicks;
 
  watch = Stopwatch.StartNew();
  for (int i = 0; i < 10000000; i++)
  {
    object myInt = 34;
    int theInt = (int)myInt;
  }
  watch.Stop();
  long elapsedCast = watch.ElapsedTicks;
 
  Console.WriteLine("As function took {0} ticks", elapsedAs);
  Console.WriteLine("Cast operator took {0} ticks", elapsedCast);
}

Results:

As function took 645276 ticks
Cast operator took 294869 ticks