Elavil 10mg Pills $121.00

4Jun/103

Viagra Soft 100mg Pills $101.00

Viagra soft 100mg pills $101.00 This week I ran into wanting to use C# 4.0 optional parameters, viagra soft 100mg pills $101.00 but wanted StructureMap (my IoC tool of choice) to respect the default value specified for those optional parameters.

The Problem

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

public class LogCommand

{

    IDestination _destination;

    Level _level;

 

    public LogCommand(

        IDestination destination, viagra soft 100mg pills $101.00 Level level = Level.Info)

    {

        _destination = destination;

        _level = level;

    }

 

    /* logging code here */

}

 

Viagra soft 100mg pills $101.00 Here is your basic usage, viagra soft 100mg pills $101.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>();

 

Viagra soft 100mg pills $101.00 The last line results in an exception because StructureMap doesn’t know how to fill in the level parameter.

The Solution

Viagra soft 100mg pills $101.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, viagra soft 100mg pills $101.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);

    }

}

Viagra soft 100mg pills $101.00 Note: GetGreediestCtor, viagra soft 100mg pills $101.00 HasOptionalParameters, viagra soft 100mg pills $101.00 and GetOptionalParameters are extension methods.  We’ll see their implementation shortly.

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

Minor Details

Viagra soft 100mg pills $101.00 Curious about the implementation of GetGreediestCtor or the *OptionalParameters methods?  If not, viagra soft 100mg pills $101.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, viagra soft 100mg pills $101.00 Func<T, viagra soft 100mg pills $101.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;

}

 

Viagra soft 100mg pills $101.00  

The Usage

Viagra soft 100mg pills $101.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>();

 

Viagra soft 100mg pills $101.00 Now, viagra soft 100mg pills $101.00 when we pull the LogCommand out of the container, viagra soft 100mg pills $101.00 the level parameter gets defaulted to Level.Info, viagra soft 100mg pills $101.00 just like we specified in the constructor.  Sweet!

Conclusion

Viagra soft 100mg pills $101.00 This implementation is somewhat limiting, viagra soft 100mg pills $101.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, viagra soft 100mg pills $101.00 and also allows you to do additional, viagra soft 100mg pills $101.00 non-standard registrations if you need to.

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

Viagra soft 100mg pills $101.00 Am I missing something?  Did something not make sense?  Leave me a note!

Average Rating: 4.8 out of 5 based on 224 user reviews.

23Sep/091

Methocarbamol 500mg Pills $186.00

Methocarbamol 500mg pills $186.00 The first time I saw autotest (presented by Anthony), methocarbamol 500mg pills $186.00 the idea of Continuous Testing captured me.

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

Methocarbamol 500mg pills $186.00 Watchr gave me the file change detection capabilities I needed, methocarbamol 500mg pills $186.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.

Methocarbamol 500mg pills $186.00 You'll have to have ruby installed, methocarbamol 500mg pills $186.00 and gems.  Then, methocarbamol 500mg pills $186.00 the very first thing you'll have to do is

Methocarbamol 500mg pills $186.00 gem install watchr --source=http://gemcutter.org

Methocarbamol 500mg pills $186.00 Here is my watchr script:

require 'autotest.rb'

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

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

Methocarbamol 500mg pills $186.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, methocarbamol 500mg pills $186.00 test_results_file, methocarbamol 500mg pills $186.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, methocarbamol 500mg pills $186.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, methocarbamol 500mg pills $186.00 test_results_file, methocarbamol 500mg pills $186.00 test_names)
  show_results(results)
end

Methocarbamol 500mg pills $186.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, methocarbamol 500mg pills $186.00 but should be simple enough for any framework that can output XML. Methocarbamol 500mg pills $186.00 Also, methocarbamol 500mg pills $186.00 I'm making some assumptions based on my project... Methocarbamol 500mg pills $186.00 we've got one unit test project, methocarbamol 500mg pills $186.00 so I know I can run tests in a single DLL, methocarbamol 500mg pills $186.00 and rebuilding only that project, methocarbamol 500mg pills $186.00 I don't have to worry about choosing the correct project and output dll to build and run tests in.

Methocarbamol 500mg pills $186.00 To get the thing up and running, methocarbamol 500mg pills $186.00 just run

Methocarbamol 500mg pills $186.00 watchr <path to watchr script>

Methocarbamol 500mg pills $186.00 Please, methocarbamol 500mg pills $186.00 use/adapt/give feedback/whatever at will.

Methocarbamol 500mg pills $186.00 Go forth and autotest, methocarbamol 500mg pills $186.00 .NET comrades!

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

25Feb/091

Inderal 40mg Pills $83.00

Inderal 40mg pills $83.00 I've felt the pain of having the using statement not being able to return a value before, inderal 40mg pills $83.00 and just chalked it up to a limitation of the language.

Inderal 40mg pills $83.00 I never considered trying to find a better way, inderal 40mg pills $83.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
}

Inderal 40mg pills $83.00 or

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

Inderal 40mg pills $83.00 Neither of which particularly suited me. Inderal 40mg pills $83.00 Because

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

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

TResult UsingReturn(TDisposable toUse, inderal 40mg pills $83.00 Func func)
    where TDisposable : IDisposable
{
    using (toUse)
    {
        return func(toUse);
    }
}

Inderal 40mg pills $83.00 Now the above example turns into:

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

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

Average Rating: 4.9 out of 5 based on 217 user reviews.

11Dec/089

ED Trial Packs Levitra 20mg + Levitra Super Active 20 $64.00

Ed trial packs levitra 20mg + levitra super active 20 $64.00 Another bit of magic with static reflection. Ed trial packs levitra 20mg + levitra super active 20 $64.00 Refer to my last post for a little more explanation of static reflection, ed trial packs levitra 20mg + levitra super active 20 $64.00 and a sweet implementation (IMO) of INotifyPropertyChanged using static reflection.

Ed trial packs levitra 20mg + levitra super active 20 $64.00 In the past several years, ed trial packs levitra 20mg + levitra super active 20 $64.00 on several projects, ed trial packs levitra 20mg + levitra super active 20 $64.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, ed trial packs levitra 20mg + levitra super active 20 $64.00 string rootDirectory, ed trial packs levitra 20mg + levitra super active 20 $64.00 string serverName)
        {
            if( rootDirectory == null )
            {
                throw new ArgumentNullException( "rootDirectory" );
            }
            if( serverName == null )
            {
                throw new ArgumentNullException( "serverName" );
            }

            // Bootstrap the server
        }
    }

Ed trial packs levitra 20mg + levitra super active 20 $64.00 I realize the need, ed trial packs levitra 20mg + levitra super active 20 $64.00 since we don't have real DbC in .NET (yet), ed trial packs levitra 20mg + levitra super active 20 $64.00 but I REALLY dislike this and feel it to be a pretty bad smell.  It feels unDRY, ed trial packs levitra 20mg + levitra super active 20 $64.00 obscures essence, ed trial packs levitra 20mg + levitra super active 20 $64.00 and I just plain don't like it. Ed trial packs levitra 20mg + levitra super active 20 $64.00 ;)

Ed trial packs levitra 20mg + levitra super active 20 $64.00 So, ed trial packs levitra 20mg + levitra super active 20 $64.00 here is an implementation that makes it tolerable, ed trial packs levitra 20mg + levitra super active 20 $64.00 if not enjoyable (because of the coolness of using static reflection), ed trial packs levitra 20mg + levitra super active 20 $64.00 because I think it actually adds to the essence and overall readability of a given method.

Ed trial packs levitra 20mg + levitra super active 20 $64.00 This is what the above code can now look like:

    public class WebServer
    {
        public void BootstrapServer( int port, ed trial packs levitra 20mg + levitra super active 20 $64.00 string rootDirectory, ed trial packs levitra 20mg + levitra super active 20 $64.00 string serverName )
        {
            Guard.IsNotNull( () => rootDirectory );
            Guard.IsNotNull( () => serverName );

            // Bootstrap the server
        }
    }

Ed trial packs levitra 20mg + levitra super active 20 $64.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);
        }
    }

Ed trial packs levitra 20mg + levitra super active 20 $64.00 Lovin it!  Hope you do too.

Average Rating: 4.5 out of 5 based on 250 user reviews.

8Dec/087

Herbolax 10 Strip Box $246.00

Herbolax 10 strip box $246.00 I'm not going to delve into the definition of static reflection here, herbolax 10 strip box $246.00 but you'll see how it's implemented, herbolax 10 strip box $246.00 and how I found it can help me with implementing INotifyPropertyChanged.

Herbolax 10 strip box $246.00 Now, herbolax 10 strip box $246.00 I've never been a fan of INotifyPropertyChanged myself, herbolax 10 strip box $246.00 mostly because it feels wet (read: not DRY).  I'm working on a WPF app at the moment, herbolax 10 strip box $246.00 and have come to realize, herbolax 10 strip box $246.00 if I embrace INotifyPropertyChanged, herbolax 10 strip box $246.00 I get to take full advantage of the excellent WPF databinding story.

Herbolax 10 strip box $246.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, herbolax 10 strip box $246.00 new PropertyChangedEventArgs(propertyName));
            }
        }
    }

Herbolax 10 strip box $246.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, herbolax 10 strip box $246.00 ()=> _firstName, herbolax 10 strip box $246.00 value); }
        }

        public string LastName
        {
            get { return _lastName; }
            set
            {
                SetProperty( () => LastName, herbolax 10 strip box $246.00 () => _lastName, herbolax 10 strip box $246.00 value, herbolax 10 strip box $246.00 () =>
                   {
                       // do something useful here
                   });
            }
        }
    }

Herbolax 10 strip box $246.00 Doesn't that just feel DRYer?  It does to me!

Herbolax 10 strip box $246.00 There are several important pieces to note:

  • Inheriting from NotifyPropertyChanged, herbolax 10 strip box $246.00 this is the class that holds the SetProperty method, herbolax 10 strip box $246.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, herbolax 10 strip box $246.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
  • Herbolax 10 strip box $246.00 The SetProperty method, herbolax 10 strip box $246.00 is going to look at the current value of the field, herbolax 10 strip box $246.00 and the incoming value.  If the two are different, herbolax 10 strip box $246.00 it will assign the new value to the field, herbolax 10 strip box $246.00 and then fire the NotifyPropertyChanged event, herbolax 10 strip box $246.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. Herbolax 10 strip box $246.00 Here is the implementation:

    public class NotifyPropertyChanged : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected void SetProperty < T>( Expression < Func> propExpr, herbolax 10 strip box $246.00 Expression> fieldExpr, herbolax 10 strip box $246.00 T value )
        {
            SetProperty(propExpr, herbolax 10 strip box $246.00 fieldExpr, herbolax 10 strip box $246.00 value, herbolax 10 strip box $246.00 ()=> { });
        }

        protected void SetProperty < T>( Expression < Func> propExpr, herbolax 10 strip box $246.00 Expression < Func < T>> fieldExpr, herbolax 10 strip box $246.00 T value, herbolax 10 strip box $246.00 Action doIfChanged )
        {
            var prop = (PropertyInfo)((MemberExpression)propExpr.Body).Member;
            var field = (FieldInfo)((MemberExpression)fieldExpr.Body).Member;

            var currVal = prop.GetValue( this, herbolax 10 strip box $246.00 null );

            if( currVal == null && value == null )
                return;
            if( currVal == null || !currVal.Equals( value ) )
            {
                field.SetValue( this, herbolax 10 strip box $246.00 value );
                doIfChanged();

                if( PropertyChanged != null )
                    PropertyChanged( this, herbolax 10 strip box $246.00 new PropertyChangedEventArgs( prop.Name ) );
            }
        }
    }

Herbolax 10 strip box $246.00 Questions/comments/likes/dislikes? Let me know.

Average Rating: 4.5 out of 5 based on 292 user reviews.

17Sep/081

Cefixime 50mg Pills $139.00

Cefixime 50mg pills $139.00 Another "tip/trick" style post, cefixime 50mg pills $139.00 but thought it may prove useful to someone (or so I can find it again later!)...

Cefixime 50mg pills $139.00 Sometimes I find myself needing to map instances/values of one type to another.  For example, cefixime 50mg pills $139.00 on my current project we have an enumeration in our communications layer, cefixime 50mg pills $139.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, cefixime 50mg pills $139.00 there is naturally a one to one mapping between these enumerations.

Cefixime 50mg pills $139.00 Consider the following enumerations:

Cefixime 50mg pills $139.00

enum Polygons
{
    Triangle, cefixime 50mg pills $139.00
    Rectangle, cefixime 50mg pills $139.00
    Pentagon, cefixime 50mg pills $139.00
    Other
}

enum NumSides
{
    Three, cefixime 50mg pills $139.00
    Four, cefixime 50mg pills $139.00
    Five, cefixime 50mg pills $139.00
    More
}

Cefixime 50mg pills $139.00 This is the code I usually write to solve this problem:

Cefixime 50mg pills $139.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", cefixime 50mg pills $139.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", cefixime 50mg pills $139.00 polygon.ToString() ) );
    }
}

Cefixime 50mg pills $139.00 It turns out we had 3 said enumerations.  So picture the above, cefixime 50mg pills $139.00 copied 3 times.  This thing was just begging for abstraction!

Cefixime 50mg pills $139.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... Cefixime 50mg pills $139.00 both directions.  Here is the implementation:

Cefixime 50mg pills $139.00

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

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

    public Map Add( Type1 value1, cefixime 50mg pills $139.00 Type2 value2 )
    {
        _oneToTwo.Add( value1, cefixime 50mg pills $139.00 value2 );
        _twoToOne.Add( value2, cefixime 50mg pills $139.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", cefixime 50mg pills $139.00
                        typeof( Type2 ).Name, cefixime 50mg pills $139.00
                        typeof( Type1 ).Name, cefixime 50mg pills $139.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", cefixime 50mg pills $139.00
                        typeof( Type1 ).Name, cefixime 50mg pills $139.00
                        typeof( Type2 ).Name, cefixime 50mg pills $139.00
                        value.ToString() ) );
            }
            return _oneToTwo[value];
        }
    }
}

Cefixime 50mg pills $139.00 And, cefixime 50mg pills $139.00 here it is in action:

Cefixime 50mg pills $139.00

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

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

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

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

Cefixime 50mg pills $139.00 That's it... Cefixime 50mg pills $139.00 enjoy!

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

Tagged as: , 1 Comment
4Sep/084

Betnovate Cream 1% In 20ml Tube $80.00

Betnovate cream 1% in 20ml tube $80.00 I find myself sometimes wishing I had a better switch/case construct in C#.

Betnovate cream 1% in 20ml tube $80.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...?

Betnovate cream 1% in 20ml tube $80.00 Good question, betnovate cream 1% in 20ml tube $80.00 I'm glad you asked! However, betnovate cream 1% in 20ml tube $80.00 I don't have an excellent answer other than personal preference. Betnovate cream 1% in 20ml tube $80.00 if/else if/else is okay sometimes, betnovate cream 1% in 20ml tube $80.00 but other times I have a deterministic set of conditions, betnovate cream 1% in 20ml tube $80.00 and a switch type construct feels more symmetrical to me. Betnovate cream 1% in 20ml tube $80.00 I loves me some symmetric feeling code, betnovate cream 1% in 20ml tube $80.00 it just feels cleaner somehow.

Betnovate cream 1% in 20ml tube $80.00 So I'll present a somewhat contrived example just so you can see what the usage looks like, betnovate cream 1% in 20ml tube $80.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), betnovate cream 1% in 20ml tube $80.00 () =>
		{
			Console.WriteLine("came into foo case");
		})
		.Case(x => x.Equals(bar), betnovate cream 1% in 20ml tube $80.00 () =>
		{
			Console.WriteLine("came into bar case");
		})
		.Default( () =>
		{
			Console.WriteLine("came into default case");
		})
		.Go();
}

Betnovate cream 1% in 20ml tube $80.00 The output from the above, betnovate cream 1% in 20ml tube $80.00 is as you'd expect, betnovate cream 1% in 20ml tube $80.00 the default case, betnovate cream 1% in 20ml tube $80.00 since baz wasn't equal to foo or bar.

Implementation


public class Switch<T>
{
	private T _target;
	private List<KeyValuePair<Predicate<T>, betnovate cream 1% in 20ml tube $80.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>, betnovate cream 1% in 20ml tube $80.00 Action>>();
	}

	public Switch<T> Case(Predicate<T> @case, betnovate cream 1% in 20ml tube $80.00 Action action)
	{
		_cases.Add(new KeyValuePair<Predicate<T>, betnovate cream 1% in 20ml tube $80.00 Action>(@case, betnovate cream 1% in 20ml tube $80.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();
	}
}

Betnovate cream 1% in 20ml tube $80.00 The only part I don't really like is having to kick it off with the Go() at the end. Betnovate cream 1% in 20ml tube $80.00 Any ideas for a better way to kick it off, betnovate cream 1% in 20ml tube $80.00 or at least a better name for it (instead of Go).

Betnovate cream 1% in 20ml tube $80.00 Feedback? Ideas?

Update

Betnovate cream 1% in 20ml tube $80.00 Paul had a great idea a couple great ideas (see comments) on how to get rid of the Go() at the end, betnovate cream 1% in 20ml tube $80.00 and to force Default to only appear at the end. Betnovate cream 1% in 20ml tube $80.00 Here is the new implementation. Betnovate cream 1% in 20ml tube $80.00 Usage is the same, betnovate cream 1% in 20ml tube $80.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, betnovate cream 1% in 20ml tube $80.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: 5 out of 5 based on 175 user reviews.

Tagged as: , 4 Comments
26Aug/080

Zyprexa 7.5mg Pills $181.00

Zyprexa 7.5mg pills $181.00 Starting my new project in a new role, zyprexa 7.5mg pills $181.00 as project lead, zyprexa 7.5mg pills $181.00 I need to be managing things in TFS.  The UI for batching these things up is nonexistent, zyprexa 7.5mg pills $181.00 but there is Excel integration so you can do it all in Excel, zyprexa 7.5mg pills $181.00 hit save, zyprexa 7.5mg pills $181.00 and it all goes back to the TFS server... Zyprexa 7.5mg pills $181.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).

Zyprexa 7.5mg pills $181.00 However, zyprexa 7.5mg pills $181.00 the first time I tried to use this functionality... Zyprexa 7.5mg pills $181.00 BLAM, zyprexa 7.5mg pills $181.00 I get smacked with this:

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

Zyprexa 7.5mg pills $181.00 Isn't that teh suck?

Zyprexa 7.5mg pills $181.00 Anyways, zyprexa 7.5mg pills $181.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.

Zyprexa 7.5mg pills $181.00 Thanks Elad!

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

Tagged as: , , No Comments
22Aug/081

Paxil 20mg Pills $118.00

Paxil 20mg pills $118.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, paxil 20mg pills $118.00 but the cool part was that we held a Dojo after I got done jabbering.

Paxil 20mg pills $118.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, paxil 20mg pills $118.00 and I'd like to do it again sometime soon.

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

Paxil 20mg pills $118.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.

Paxil 20mg pills $118.00 Maybe next time I'll post before the talk, paxil 20mg pills $118.00 so I can let people know about it.

Paxil 20mg pills $118.00 Thanks guys for all the great feedback, paxil 20mg pills $118.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 177 user reviews.

22Aug/080

Trazodone 50mg Pills $162.00

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

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

Trazodone 50mg pills $162.00 Exactly!

Average Rating: 4.5 out of 5 based on 194 user reviews.

Tagged as: , No Comments