Deltasone 5mg Pills $74.00

4Jun/103

Leukeran 5mg Pills $272.00

Leukeran 5mg pills $272.00 This week I ran into wanting to use C# 4.0 optional parameters, leukeran 5mg pills $272.00 but wanted StructureMap (my IoC tool of choice) to respect the default value specified for those optional parameters.

The Problem

Leukeran 5mg pills $272.00 In this example, leukeran 5mg pills $272.00 we’ll be pulling a command out of the container.  The important part is the optional constructor parameter (level), leukeran 5mg pills $272.00 and it’s default value (Level.Info).

public class LogCommand

{

    IDestination _destination;

    Level _level;

 

    public LogCommand(

        IDestination destination, leukeran 5mg pills $272.00 Level level = Level.Info)

    {

        _destination = destination;

        _level = level;

    }

 

    /* logging code here */

}

 

Leukeran 5mg pills $272.00 Here is your basic usage, leukeran 5mg pills $272.00 but doesn’t work since StructureMap doesn’t know how to take advantage of the optional parameters with default values.

var container = new Container(config =>

{

    config.Scan(scanner =>

    {

        scanner.TheCallingAssembly();

        scanner.AddAllTypesOf<IDestination>();

        scanner.WithDefaultConventions();

    });

});

 

var logCommand = container.GetInstance<LogCommand>();

 

Leukeran 5mg pills $272.00 The last line results in an exception because StructureMap doesn’t know how to fill in the level parameter.

The Solution

Leukeran 5mg pills $272.00 We can solve this by adding a new convention.  One that adds information about default constructor arguments.  Here is the implementation of the convention:

public class DefaultCtorParameterConvention : IRegistrationConvention

{

    public void Process(Type type, leukeran 5mg pills $272.00 Registry registry)

    {

        if(type.IsAbstract || type.IsEnum)

            return;

 

        var ctor = type.GetGreediestCtor();

 

        if(!ctor.HasOptionalParameters())

            return;

 

        var inst = registry.For(type).Use(type);

 

        foreach(var param in ctor.GetOptionalParameters())

            inst.Child(param.Name).Is(param.DefaultValue);

    }

}

Leukeran 5mg pills $272.00 Note: GetGreediestCtor, leukeran 5mg pills $272.00 HasOptionalParameters, leukeran 5mg pills $272.00 and GetOptionalParameters are extension methods.  We’ll see their implementation shortly.

Leukeran 5mg pills $272.00 The convention inherits from the IRegistrationConvention, leukeran 5mg pills $272.00 which is how you implement new conventions in StructureMap.  It has only one method: Process.  We filter out types that are abstract, leukeran 5mg pills $272.00 are enums, leukeran 5mg pills $272.00 or have constructors that don’t have optional parameters.  Once we realize we have a constructor we want to deal with, leukeran 5mg pills $272.00 we use the Child method, leukeran 5mg pills $272.00 that sets either a property or a constructor argument (for our case, leukeran 5mg pills $272.00 it’ll always be a constructor argument), leukeran 5mg pills $272.00 and then we set it’s value to the parameter’s default value, leukeran 5mg pills $272.00 as provided by the ParameterInfo object, leukeran 5mg pills $272.00 for each optional parameter.

Minor Details

Leukeran 5mg pills $272.00 Curious about the implementation of GetGreediestCtor or the *OptionalParameters methods?  If not, leukeran 5mg pills $272.00 skip this section.

public static bool HasOptionalParameters(

    this ConstructorInfo ctor)

{

    return ctor.GetOptionalParameters().Any();

}

 

public static IEnumerable<ParameterInfo> GetOptionalParameters(this ConstructorInfo ctor)

{

    return ctor.GetParameters().Where(

        param => param.Attributes

            .HasFlag(ParameterAttributes.Optional));

}

 

public static ConstructorInfo GetGreediestCtor(

    this Type target)

{

    return target.GetConstructors()

        .WithMax(ctor => ctor.GetParameters().Length);

}

 

public static T WithMax<T>(

    this IEnumerable<T> target, leukeran 5mg pills $272.00 Func<T, leukeran 5mg pills $272.00 int> selector)

{

    int max = -1;

    T currentMax = default(T);

 

    foreach(var item in target)

    {

        var current = selector(item);

        if(current <= max)

            continue;

 

        max = current;

        currentMax = item;

    }

 

    return currentMax;

}

 

Leukeran 5mg pills $272.00  

The Usage

Leukeran 5mg pills $272.00 Here’s how to use your new convention.

var container = new Container(config =>

{

   config.Scan(scanner =>

   {

       scanner.TheCallingAssembly();

       scanner.AddAllTypesOf<IDestination>();

       scanner.WithDefaultConventions();

       scanner.Convention<DefaultCtorParameterConvention>();

   });

});

 

var logCommand = container.GetInstance<LogCommand>();

 

Leukeran 5mg pills $272.00 Now, leukeran 5mg pills $272.00 when we pull the LogCommand out of the container, leukeran 5mg pills $272.00 the level parameter gets defaulted to Level.Info, leukeran 5mg pills $272.00 just like we specified in the constructor.  Sweet!

Conclusion

Leukeran 5mg pills $272.00 This implementation is somewhat limiting, leukeran 5mg pills $272.00 but the version I have in my github repo is a little more open and configurable.  It allows you to customize the instance key/name you use when registering your type, leukeran 5mg pills $272.00 and also allows you to do additional, leukeran 5mg pills $272.00 non-standard registrations if you need to.

Leukeran 5mg pills $272.00 Also, leukeran 5mg pills $272.00 this doesn’t work if you’ve selected a constructor using the SelectConstructor config API from StructureMap, leukeran 5mg pills $272.00 I’m not sure how to tap into that facility to look for that constructor rather than the greediest.

Leukeran 5mg pills $272.00 Am I missing something?  Did something not make sense?  Leave me a note!

Average Rating: 4.4 out of 5 based on 171 user reviews.

23Sep/091

Moduretic 5mg Pills $83.00

Moduretic 5mg pills $83.00 The first time I saw autotest (presented by Anthony), moduretic 5mg pills $83.00 the idea of Continuous Testing captured me.

Moduretic 5mg pills $83.00 I live in a .NET world most of the time, moduretic 5mg pills $83.00 and I know of no similar solution for .NET.  It’s been awhile since that first time, moduretic 5mg pills $83.00 and I’ve tinkered here and there trying to get something comparable, moduretic 5mg pills $83.00 but usually come up short.  That is until I found watchr.

Moduretic 5mg pills $83.00 Watchr gave me the file change detection capabilities I needed, moduretic 5mg pills $83.00 and the extensibility to do whatever I want when a file has been detected as changed.  This made it incredibly easy to hook up some autotest goodness in my .NET world.

Moduretic 5mg pills $83.00 You'll have to have ruby installed, moduretic 5mg pills $83.00 and gems.  Then, moduretic 5mg pills $83.00 the very first thing you'll have to do is

Moduretic 5mg pills $83.00 gem install watchr --source=http://gemcutter.org

Moduretic 5mg pills $83.00 Here is my watchr script:

require 'autotest.rb'

watch( '^.*UnitTest.*.cs$' ) do |match|
  run_test(match.to_s)
end

Moduretic 5mg pills $83.00 This is basically just a regex that says to watch any *.cs files that also contain the string “UnitTest”, moduretic 5mg pills $83.00 and when it finds a change in a file matching that description, moduretic 5mg pills $83.00 call run_test with the matched file name.

Moduretic 5mg pills $83.00 So all the magic is in autotest.rb… lets check it out:

require 'rexml/document'

def build(test_project)
  `msbuild /nologo #{test_project}`
end

def mstest(test_container, moduretic 5mg pills $83.00 test_results_file, moduretic 5mg pills $83.00 tests_to_run)
  tests_to_run = ([""] << tests_to_run).flatten

  File.delete(test_results_file) if File.exists?(test_results_file)
  `mstest /nologo /resultsfile:#{test_results_file} /testcontainer:#{test_container} #{tests_to_run.join(" /test:")}`
  test_results = process_mstest_results(test_results_file)
  File.delete(test_results_file) if File.exists?(test_results_file)

  return test_results
end

def process_mstest_results(results_file)
  results = {}
  File.open(results_file) do |file|
    xml = REXML::Document.new(file)

    results[:num_tests] = xml.get_elements("//UnitTestResult").length
    failures = []
    xml.elements.each("//UnitTestResult[@outcome='Failed']") do |e|
      failure = {}
      failure[:message] = e.elements["Output/ErrorInfo/Message"].get_text

      stack = e.elements["Output/ErrorInfo/StackTrace"].get_text.value
      stack_match = /^.*at (.*) in(.*):line (\d+)$/.match(stack)

      failure[:stack] = stack_match[1] if stack_match
      failure[:location] = stack_match[2] if stack_match
      failure[:line] = stack_match[3] if stack_match

      failure[:stack] = stack if !stack_match

      failures << failure
    end
    results[:failures] = failures
  end

  return results
end

def show_results(results)
  puts "#{results[:num_tests]} tests run (#{results[:failures].length} failures)"
  results[:failures].each do |failure|
      puts "---------------------------------------"
      puts "Message: #{failure[:message]}"
      puts "Location: #{failure[:location]}"
      puts "Line: #{failure[:line]}"
      puts "Stack Trace: #{failure[:stack]}"
  end
end

def run_test(file_name)
  test_container = ""
  test_results_file = "result.trx"
  test_project = ""

  system("cls")
  system("echo Detected change in:")
  system("echo   #{file_name}")
  system("echo Building and Testing")

  test_namespace = ''
  test_class = ''
  test_names = []

  File.open(file_name, moduretic 5mg pills $83.00 "r") do |f|
    f.each do |line|
      ns_match = /^namespace (.*)$/.match(line)
      test_namespace = ns_match[1] if ns_match

      class_match = /^\s*public class (.\w*).*$/.match(line)
      test_class = class_match[1] if class_match

      test_name_match = /^\s*public void (\w*).*$/.match(line)
      test_names << test_name_match[1] if test_name_match
    end
  end

  test_names = test_names.map { |n| "#{test_namespace}.#{test_class}.#{n}" }

  build(test_project)
  results = mstest(test_container, moduretic 5mg pills $83.00 test_results_file, moduretic 5mg pills $83.00 test_names)
  show_results(results)
end

Moduretic 5mg pills $83.00 The key parts (I think) are the fact that I’m using MSTest to run my tests (this can easily be modified to run your framework of choice… note MSTest is not my choice ;) ).  The result parsing is also specific to the MSTest output format, moduretic 5mg pills $83.00 but should be simple enough for any framework that can output XML. Moduretic 5mg pills $83.00 Also, moduretic 5mg pills $83.00 I'm making some assumptions based on my project... Moduretic 5mg pills $83.00 we've got one unit test project, moduretic 5mg pills $83.00 so I know I can run tests in a single DLL, moduretic 5mg pills $83.00 and rebuilding only that project, moduretic 5mg pills $83.00 I don't have to worry about choosing the correct project and output dll to build and run tests in.

Moduretic 5mg pills $83.00 To get the thing up and running, moduretic 5mg pills $83.00 just run

Moduretic 5mg pills $83.00 watchr <path to watchr script>

Moduretic 5mg pills $83.00 Please, moduretic 5mg pills $83.00 use/adapt/give feedback/whatever at will.

Moduretic 5mg pills $83.00 Go forth and autotest, moduretic 5mg pills $83.00 .NET comrades!

Average Rating: 5 out of 5 based on 290 user reviews.

25Feb/091

Primaquine 7.5mg Pills $315.00

Primaquine 7.5mg pills $315.00 I've felt the pain of having the using statement not being able to return a value before, primaquine 7.5mg pills $315.00 and just chalked it up to a limitation of the language.

Primaquine 7.5mg pills $315.00 I never considered trying to find a better way, primaquine 7.5mg pills $315.00 and usually ended up with something like:

void DoSomething()
{
    XmlDocument xml = new XmlDocument();
    using(var reader = new StreamReader(@"c:\somexmlfile.xml"))
    {
        xml.Load(reader);
    }

    // do something useful with xml
}

Primaquine 7.5mg pills $315.00 or

void DoSomething2()
{
    XmlDocument xml = new XmlDocument();
    using( var reader = new StreamReader( @"c:\somexmlfile.xml" ) )
    {
        xml.Load( reader );
        // do something useful with xml
    }
}

Primaquine 7.5mg pills $315.00 Neither of which particularly suited me. Primaquine 7.5mg pills $315.00 Because

  • First example: Declaring the variable outside the scope of the block feels weird
  • Second example: Performing whatever operation inside the using block, primaquine 7.5mg pills $315.00 means the file (or other resource) doesn't get released until the operation has completed.

Primaquine 7.5mg pills $315.00 After Shawn mentioned something about this at his Indy Alt.Net Clojure talk, primaquine 7.5mg pills $315.00 I started thinking about it a little bit, primaquine 7.5mg pills $315.00 and then I had a real need for it (again), primaquine 7.5mg pills $315.00 and decided to come up with something better.  Turns out what I wanted was blatantly simple.

TResult UsingReturn(TDisposable toUse, primaquine 7.5mg pills $315.00 Func func)
    where TDisposable : IDisposable
{
    using (toUse)
    {
        return func(toUse);
    }
}

Primaquine 7.5mg pills $315.00 Now the above example turns into:

void DoSomething3()
{
    var xml = UsingReturn( new StreamReader( @"c:\cdf.xml" ), primaquine 7.5mg pills $315.00 reader =>
                {
                    var doc = new XmlDocument();
                    doc.Load( reader );
                    return doc;
                });
}

Primaquine 7.5mg pills $315.00 I'm not sure where this thing should live (e.g. Primaquine 7.5mg pills $315.00 some static utility class, primaquine 7.5mg pills $315.00 extension method on IDisposable), primaquine 7.5mg pills $315.00 or even what it should be called.  Any ideas?

Average Rating: 4.4 out of 5 based on 225 user reviews.

11Dec/089

Aciphex 20mg Pills $89.00

Aciphex 20mg pills $89.00 Another bit of magic with static reflection. Aciphex 20mg pills $89.00 Refer to my last post for a little more explanation of static reflection, aciphex 20mg pills $89.00 and a sweet implementation (IMO) of INotifyPropertyChanged using static reflection.

Aciphex 20mg pills $89.00 In the past several years, aciphex 20mg pills $89.00 on several projects, aciphex 20mg pills $89.00 I've seen many lines of code at the beginning of public interface methods that look like:

    public class WebServer
    {
        public void BootstrapServer(int port, aciphex 20mg pills $89.00 string rootDirectory, aciphex 20mg pills $89.00 string serverName)
        {
            if( rootDirectory == null )
            {
                throw new ArgumentNullException( "rootDirectory" );
            }
            if( serverName == null )
            {
                throw new ArgumentNullException( "serverName" );
            }

            // Bootstrap the server
        }
    }

Aciphex 20mg pills $89.00 I realize the need, aciphex 20mg pills $89.00 since we don't have real DbC in .NET (yet), aciphex 20mg pills $89.00 but I REALLY dislike this and feel it to be a pretty bad smell.  It feels unDRY, aciphex 20mg pills $89.00 obscures essence, aciphex 20mg pills $89.00 and I just plain don't like it. Aciphex 20mg pills $89.00 ;)

Aciphex 20mg pills $89.00 So, aciphex 20mg pills $89.00 here is an implementation that makes it tolerable, aciphex 20mg pills $89.00 if not enjoyable (because of the coolness of using static reflection), aciphex 20mg pills $89.00 because I think it actually adds to the essence and overall readability of a given method.

Aciphex 20mg pills $89.00 This is what the above code can now look like:

    public class WebServer
    {
        public void BootstrapServer( int port, aciphex 20mg pills $89.00 string rootDirectory, aciphex 20mg pills $89.00 string serverName )
        {
            Guard.IsNotNull( () => rootDirectory );
            Guard.IsNotNull( () => serverName );

            // Bootstrap the server
        }
    }

Aciphex 20mg pills $89.00 And here is the implementation:

    public static class Guard
    {
        public static void IsNotNull<T>(Expression<Func<T>> expr)
        {
            // expression value != default of T
            if (!expr.Compile()().Equals(default(T)))
                return;

            var param = (MemberExpression) expr.Body;
            throw new ArgumentNullException(param.Member.Name);
        }
    }

Aciphex 20mg pills $89.00 Lovin it!  Hope you do too.

Average Rating: 4.6 out of 5 based on 160 user reviews.

8Dec/087

Trazodone 25mg Pills $137.00

Trazodone 25mg pills $137.00 I'm not going to delve into the definition of static reflection here, trazodone 25mg pills $137.00 but you'll see how it's implemented, trazodone 25mg pills $137.00 and how I found it can help me with implementing INotifyPropertyChanged.

Trazodone 25mg pills $137.00 Now, trazodone 25mg pills $137.00 I've never been a fan of INotifyPropertyChanged myself, trazodone 25mg pills $137.00 mostly because it feels wet (read: not DRY).  I'm working on a WPF app at the moment, trazodone 25mg pills $137.00 and have come to realize, trazodone 25mg pills $137.00 if I embrace INotifyPropertyChanged, trazodone 25mg pills $137.00 I get to take full advantage of the excellent WPF databinding story.

Trazodone 25mg pills $137.00 Here is what a normal use of INotifyPropertyChanged looks like:

    public class Person : INotifyPropertyChanged
    {
        private string _firstName;
        private string _lastName;

        public event PropertyChangedEventHandler PropertyChanged;

        public string FirstName
        {
            get { return _firstName; }
            set
            {
                if (_firstName != value)
                {
                    _firstName = value;
                    FirePropertyChanged("FirstName");
                }
            }
        }

        public string LastName
        {
            get { return _lastName; }
            set
            {
                if (_lastName != value)
                {
                    _lastName = value;
                    FirePropertyChanged("LastName");
                }
            }
        }

        private void FirePropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, trazodone 25mg pills $137.00 new PropertyChangedEventArgs(propertyName));
            }
        }
    }

Trazodone 25mg pills $137.00 Here is what the static reflection use of INotifyPropertyChanged looks like:

    public class PersonStaticReflection : NotifyPropertyChanged
    {
        private string _firstName;
        private string _lastName;

        public string FirstName
        {
            get { return _firstName; }
            set { SetProperty(()=> FirstName, trazodone 25mg pills $137.00 ()=> _firstName, trazodone 25mg pills $137.00 value); }
        }

        public string LastName
        {
            get { return _lastName; }
            set
            {
                SetProperty( () => LastName, trazodone 25mg pills $137.00 () => _lastName, trazodone 25mg pills $137.00 value, trazodone 25mg pills $137.00 () =>
                   {
                       // do something useful here
                   });
            }
        }
    }

Trazodone 25mg pills $137.00 Doesn't that just feel DRYer?  It does to me!

Trazodone 25mg pills $137.00 There are several important pieces to note:

  • Inheriting from NotifyPropertyChanged, trazodone 25mg pills $137.00 this is the class that holds the SetProperty method, trazodone 25mg pills $137.00 and hides the static reflection magic.
  • We're calling SetProperty with three arguments in the FirstName property
    • first: a LINQ Expression pointing to the property we're changing
    • second: a LINQ Expression pointing to the field to backing the property
    • third: the new, trazodone 25mg pills $137.00 incoming value
  • We're calling SetProperty with a fourth argument in the LastName property
    • fourth: an action that will get executed only if the values were different
  • Trazodone 25mg pills $137.00 The SetProperty method, trazodone 25mg pills $137.00 is going to look at the current value of the field, trazodone 25mg pills $137.00 and the incoming value.  If the two are different, trazodone 25mg pills $137.00 it will assign the new value to the field, trazodone 25mg pills $137.00 and then fire the NotifyPropertyChanged event, trazodone 25mg pills $137.00 with the name of the property given via the first argument.  I ended up pulling this into its own class so I could use it as the layer supertype in my View Model layer. Trazodone 25mg pills $137.00 Here is the implementation:

    public class NotifyPropertyChanged : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected void SetProperty < T>( Expression < Func> propExpr, trazodone 25mg pills $137.00 Expression> fieldExpr, trazodone 25mg pills $137.00 T value )
        {
            SetProperty(propExpr, trazodone 25mg pills $137.00 fieldExpr, trazodone 25mg pills $137.00 value, trazodone 25mg pills $137.00 ()=> { });
        }

        protected void SetProperty < T>( Expression < Func> propExpr, trazodone 25mg pills $137.00 Expression < Func < T>> fieldExpr, trazodone 25mg pills $137.00 T value, trazodone 25mg pills $137.00 Action doIfChanged )
        {
            var prop = (PropertyInfo)((MemberExpression)propExpr.Body).Member;
            var field = (FieldInfo)((MemberExpression)fieldExpr.Body).Member;

            var currVal = prop.GetValue( this, trazodone 25mg pills $137.00 null );

            if( currVal == null && value == null )
                return;
            if( currVal == null || !currVal.Equals( value ) )
            {
                field.SetValue( this, trazodone 25mg pills $137.00 value );
                doIfChanged();

                if( PropertyChanged != null )
                    PropertyChanged( this, trazodone 25mg pills $137.00 new PropertyChangedEventArgs( prop.Name ) );
            }
        }
    }

Trazodone 25mg pills $137.00 Questions/comments/likes/dislikes? Let me know.

Average Rating: 4.6 out of 5 based on 164 user reviews.

17Sep/081

Prilosec 20mg Pills $170.00

Prilosec 20mg pills $170.00 Another "tip/trick" style post, prilosec 20mg pills $170.00 but thought it may prove useful to someone (or so I can find it again later!)...

Prilosec 20mg pills $170.00 Sometimes I find myself needing to map instances/values of one type to another.  For example, prilosec 20mg pills $170.00 on my current project we have an enumeration in our communications layer, prilosec 20mg pills $170.00 and a VERY similar one in the domain layer.  The reason for this is so we don't have to be referencing the communications layer version all over in the domain code.  So, prilosec 20mg pills $170.00 there is naturally a one to one mapping between these enumerations.

Prilosec 20mg pills $170.00 Consider the following enumerations:

Prilosec 20mg pills $170.00

enum Polygons
{
    Triangle, prilosec 20mg pills $170.00
    Rectangle, prilosec 20mg pills $170.00
    Pentagon, prilosec 20mg pills $170.00
    Other
}

enum NumSides
{
    Three, prilosec 20mg pills $170.00
    Four, prilosec 20mg pills $170.00
    Five, prilosec 20mg pills $170.00
    More
}

Prilosec 20mg pills $170.00 This is the code I usually write to solve this problem:

Prilosec 20mg pills $170.00

private Polygons MapShapes( NumSides sides )
{
    switch( sides )
    {
        case NumSides.Three:
            return Polygons.Triangle;
        case NumSides.Four:
            return Polygons.Rectangle;
        case NumSides.Five:
            return Polygons.Pentagon;
        case NumSides.More:
            return Polygons.Other;
        default:
            throw new NotSupportedException(
                string.Format( "Mapping to Polygons from NumSides value {0}
                    is not supported", prilosec 20mg pills $170.00 sides.ToString() ) );
    }
}

private NumSides MapShapes( Polygons polygon )
{
    switch( polygon )
    {
        case Polygons.Triangle:
            return NumSides.Three;
        case Polygons.Rectangle:
            return NumSides.Four;
        case Polygons.Pentagon:
            return NumSides.Five;
        case Polygons.Other:
            return NumSides.More;
        default:
            throw new NotSupportedException(
                string.Format( "Mapping to NumSides from Polygons value {0}
                    is not supported", prilosec 20mg pills $170.00 polygon.ToString() ) );
    }
}

Prilosec 20mg pills $170.00 It turns out we had 3 said enumerations.  So picture the above, prilosec 20mg pills $170.00 copied 3 times.  This thing was just begging for abstraction!

Prilosec 20mg pills $170.00 I came up with a Generic (proper) Map class that you can add mappings to and retrieve the corresponding mapped value of the other type... Prilosec 20mg pills $170.00 both directions.  Here is the implementation:

Prilosec 20mg pills $170.00

public class Map
{
    private Dictionary _oneToTwo;
    private Dictionary _twoToOne;

    public Map()
    {
        _oneToTwo = new Dictionary();
        _twoToOne = new Dictionary();
    }

    public Map Add( Type1 value1, prilosec 20mg pills $170.00 Type2 value2 )
    {
        _oneToTwo.Add( value1, prilosec 20mg pills $170.00 value2 );
        _twoToOne.Add( value2, prilosec 20mg pills $170.00 value1 );
        return this;
    }

    public Type1 this[Type2 value]
    {
        get
        {
            if( !_twoToOne.ContainsKey( value ) )
            {
                throw new NotSupportedException(
                    string.Format( "Mapping from type {0} to type {1} with
                                    value {2} is not defined", prilosec 20mg pills $170.00
                        typeof( Type2 ).Name, prilosec 20mg pills $170.00
                        typeof( Type1 ).Name, prilosec 20mg pills $170.00
                        value.ToString() ) );
            }
            return _twoToOne[value];
        }
    }

    public Type2 this[Type1 value]
    {
        get
        {
            if( !_oneToTwo.ContainsKey( value ) )
            {
                throw new NotSupportedException(
                    string.Format( "Mapping from type {0} to type {1} with
                                    value {2} is not defined", prilosec 20mg pills $170.00
                        typeof( Type1 ).Name, prilosec 20mg pills $170.00
                        typeof( Type2 ).Name, prilosec 20mg pills $170.00
                        value.ToString() ) );
            }
            return _oneToTwo[value];
        }
    }
}

Prilosec 20mg pills $170.00 And, prilosec 20mg pills $170.00 here it is in action:

Prilosec 20mg pills $170.00

Map<NumSides, prilosec 20mg pills $170.00 Polygons> shapeMap = new Map<NumSides, prilosec 20mg pills $170.00 Polygons>()
                                    .Add( NumSides.Three, prilosec 20mg pills $170.00 Polygons.Triangle )
                                    .Add( NumSides.Four, prilosec 20mg pills $170.00 Polygons.Rectangle )
                                    .Add( NumSides.Five, prilosec 20mg pills $170.00 Polygons.Pentagon )
                                    .Add( NumSides.More, prilosec 20mg pills $170.00 Polygons.Other );

// shape1 value is Polygons.Rectangle
Polygons shape1 = shapeMap[NumSides.Four]; 

// shape2 value is NumSides.Three
NumSides shape2 = shapeMap[Polygons.Triangle];

Prilosec 20mg pills $170.00 This not only works with enumerations, prilosec 20mg pills $170.00 but any type.  I see an extension to this possibly allowing for a default mapping, prilosec 20mg pills $170.00 and possibly constraining Type1 and Type2 to be IComparable or something like that as well, prilosec 20mg pills $170.00 so you can have more control over your matching than whatever the default matching behavior that the Dictionary uses is.

Prilosec 20mg pills $170.00 That's it... Prilosec 20mg pills $170.00 enjoy!

Average Rating: 4.4 out of 5 based on 235 user reviews.

Tagged as: , 1 Comment
4Sep/084

Speman 60 Tablet Bottle $398.00

Speman 60 tablet bottle $398.00 I find myself sometimes wishing I had a better switch/case construct in C#.

Speman 60 tablet bottle $398.00 My requirements of "better" are:

  • Case statements are automatically scoped
  • I can switch on more than simple types
  • I can have custom logic for my matching criteria

But why not just use if/else if/else...?

Speman 60 tablet bottle $398.00 Good question, speman 60 tablet bottle $398.00 I'm glad you asked! However, speman 60 tablet bottle $398.00 I don't have an excellent answer other than personal preference. Speman 60 tablet bottle $398.00 if/else if/else is okay sometimes, speman 60 tablet bottle $398.00 but other times I have a deterministic set of conditions, speman 60 tablet bottle $398.00 and a switch type construct feels more symmetrical to me. Speman 60 tablet bottle $398.00 I loves me some symmetric feeling code, speman 60 tablet bottle $398.00 it just feels cleaner somehow.

Speman 60 tablet bottle $398.00 So I'll present a somewhat contrived example just so you can see what the usage looks like, speman 60 tablet bottle $398.00 then we'll see the code.

Usage


public void DoSomething()
{
	object foo = new object();
	object bar = new object();
	object baz = new object();

	Switch<object>.On(baz)
		.Case(x => x.Equals(foo), speman 60 tablet bottle $398.00 () =>
		{
			Console.WriteLine("came into foo case");
		})
		.Case(x => x.Equals(bar), speman 60 tablet bottle $398.00 () =>
		{
			Console.WriteLine("came into bar case");
		})
		.Default( () =>
		{
			Console.WriteLine("came into default case");
		})
		.Go();
}

Speman 60 tablet bottle $398.00 The output from the above, speman 60 tablet bottle $398.00 is as you'd expect, speman 60 tablet bottle $398.00 the default case, speman 60 tablet bottle $398.00 since baz wasn't equal to foo or bar.

Implementation


public class Switch<T>
{
	private T _target;
	private List<KeyValuePair<Predicate<T>, speman 60 tablet bottle $398.00 Action>> _cases;
	private Action _default;

	public static Switch<T> On(T target)
	{
		return new Switch<T>(target);
	}

	public Switch(T target)
	{
		_target = target;
		_cases = new List<KeyValuePair<Predicate<T>, speman 60 tablet bottle $398.00 Action>>();
	}

	public Switch<T> Case(Predicate<T> @case, speman 60 tablet bottle $398.00 Action action)
	{
		_cases.Add(new KeyValuePair<Predicate<T>, speman 60 tablet bottle $398.00 Action>(@case, speman 60 tablet bottle $398.00 action));
		return this;
	}

	public Switch<T> Default(Action action)
	{
		_default = action;
		return this;
	}

	public void Go()
	{
		foreach(var @case in _cases)
			if (@case.Key(_target))
			{
				@case.Value();
				return;
			}
		if (_default != null)
			_default();
	}
}

Speman 60 tablet bottle $398.00 The only part I don't really like is having to kick it off with the Go() at the end. Speman 60 tablet bottle $398.00 Any ideas for a better way to kick it off, speman 60 tablet bottle $398.00 or at least a better name for it (instead of Go).

Speman 60 tablet bottle $398.00 Feedback? Ideas?

Update

Speman 60 tablet bottle $398.00 Paul had a great idea a couple great ideas (see comments) on how to get rid of the Go() at the end, speman 60 tablet bottle $398.00 and to force Default to only appear at the end. Speman 60 tablet bottle $398.00 Here is the new implementation. Speman 60 tablet bottle $398.00 Usage is the same, speman 60 tablet bottle $398.00 just remove the Go().


public class Switch<T>
{
	private T _target;
	private bool _alreadyMatched;

	public static Switch<T> On(T target)
	{
		return new Switch<T>(target);
	}

	public Switch(T target)
	{
		_target = target;
		_alreadyMatched = false;
	}

	public Switch<T> Case(Predicate<T> @case, speman 60 tablet bottle $398.00 Action action)
	{
		if (!_alreadyMatched && @case(_target))
		{
			_alreadyMatched = true;
			action();
		}
		return this;
	}

	public void Default(Action action)
	{
		if (!_alreadyMatched)
		{
			_alreadyMatched = true;
			action();
		}
		return this;
	}
}

Average Rating: 4.7 out of 5 based on 196 user reviews.

Tagged as: , 4 Comments
26Aug/080

Zebeta 10mg Pills $174.00

Zebeta 10mg pills $174.00 Starting my new project in a new role, zebeta 10mg pills $174.00 as project lead, zebeta 10mg pills $174.00 I need to be managing things in TFS.  The UI for batching these things up is nonexistent, zebeta 10mg pills $174.00 but there is Excel integration so you can do it all in Excel, zebeta 10mg pills $174.00 hit save, zebeta 10mg pills $174.00 and it all goes back to the TFS server... Zebeta 10mg pills $174.00 pretty slick I must say (I was actually in the midst of writing such a tool when I realized this functionality already existed OOB).

Zebeta 10mg pills $174.00 However, zebeta 10mg pills $174.00 the first time I tried to use this functionality... Zebeta 10mg pills $174.00 BLAM, zebeta 10mg pills $174.00 I get smacked with this:

Zebeta 10mg pills $174.00 TF80042: The document cannot be opened because you do not have Microsoft Excel 2003 or later, zebeta 10mg pills $174.00 or one of its components installed. Zebeta 10mg pills $174.00 For more information, zebeta 10mg pills $174.00 see the Team Foundation Installation Guide.

Zebeta 10mg pills $174.00 Isn't that teh suck?

Zebeta 10mg pills $174.00 Anyways, zebeta 10mg pills $174.00 there is a sweet write-up on how to fix it here: http://blogs.microsoft.co.il/blogs/srlteam/archive/2007/07/17/Error-when-trying-to-export-queries-to-Excel.aspx.

Zebeta 10mg pills $174.00 Thanks Elad!

Average Rating: 4.4 out of 5 based on 233 user reviews.

Tagged as: , , No Comments
22Aug/081

Casodex 50mg Pills $424.00

Casodex 50mg pills $424.00 So last night I gave a talk at Indy ALT.NET on Castle MonoRail.  It was really just a sort of intro to MonoRail type of deal, casodex 50mg pills $424.00 but the cool part was that we held a Dojo after I got done jabbering.

Casodex 50mg pills $424.00 We ended up building a Poll Generator for our dojo activity.  We almost got done in the 45 minutes or so that we dojo'd.  It was a pretty fun activity, casodex 50mg pills $424.00 and I'd like to do it again sometime soon.

Casodex 50mg pills $424.00 Also, casodex 50mg pills $424.00 this was really my first public speaking engagement to our technical community, casodex 50mg pills $424.00 and let me say it was a blast.  Everyone had great things to say, casodex 50mg pills $424.00 and many great questions were asked too.

Casodex 50mg pills $424.00 I set up a google code repository so you can grab my slidedeck and grab the source for our dojo activity and my demo app.

Casodex 50mg pills $424.00 Maybe next time I'll post before the talk, casodex 50mg pills $424.00 so I can let people know about it.

Casodex 50mg pills $424.00 Thanks guys for all the great feedback, casodex 50mg pills $424.00 and thanks to my wife for understanding why I wasn't spending any of my evenings with her this week!

Average Rating: 4.7 out of 5 based on 200 user reviews.

22Aug/080

Paxil 20mg Pills $245.00

Paxil 20mg pills $245.00 Wowza!  So I've begun reading LosTechies (tons of great content, paxil 20mg pills $245.00 highly recommended!), paxil 20mg pills $245.00 and came across a passage today from Jimmy Bogard, paxil 20mg pills $245.00 who says what I feel, paxil 20mg pills $245.00 but what I couldn't get out of my head:

Paxil 20mg pills $245.00 On a sidenote, paxil 20mg pills $245.00 it always bothered me when people say that an interface with one implementation is a design smell.  No, paxil 20mg pills $245.00 an interface is used to expose a contract.  Interfaces communicate design intent, paxil 20mg pills $245.00 far better than a class might.

Paxil 20mg pills $245.00 Exactly!

Average Rating: 4.7 out of 5 based on 158 user reviews.

Tagged as: , No Comments