Dependency Injection Pattern in Java using Spring (part 4)

Posted on by

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany.app</groupId>
    <artifactId>my-module</artifactId>
    <version>1</version>
 
    <dependencies>
		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.2.2.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <defaultGoal>compile</defaultGoal>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.5.1</version>
                <executions>
                    <execution>
                        <id>copy1</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>.\lib</outputDirectory>
                            <!-- other configurations here -->
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

IValidator.java

package com.compare;

public interface IValidator<T> {
    boolean isValid(T instance);
}

GreaterThanFourValidator.java

package com.compare;

public class GreaterThanFourValidator implements IValidator<Integer> {

    @Override
    public boolean isValid(Integer instance) {
        return instance > 4;
    }
}

IntegerOnlyValidator.java

package com.compare;

public class IntegerOnlyValidator implements IValidator<String>{

    @Override
    public boolean isValid(String instance) {
        int i = 0;
        boolean b = false;
        try {
            Integer.parseInt(instance);
            b = true;
        }
        catch (Exception e)
        {
        }
        return b;
    }
}

GreaterThanFourValidatorTest.java

package com.compare;

public class GreaterThanFourValidatorTest {
    IValidator<Integer> validator;

    public IValidator<Integer> getValidator() {
        return validator;
    }

    public void setValidator(IValidator<Integer> validator) {
        this.validator = validator;
    }
}

IntegerOnlyValidatorTest.java

package com.compare;

public class IntegerOnlyValidatorTest {
    IValidator<String> validator;

    public IValidator<String> getValidator() {
        return validator;
    }

    public void setValidator(IValidator<String> validator) {
        this.validator = validator;
    }
}

Main.java

package com.compare;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {
        try(ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml")) {
            IntegerOnlyValidatorTest intOnly = (IntegerOnlyValidatorTest) context.getBean("IntegerOnlyTest");
            System.out.println(intOnly.validator.isValid("5554"));
            System.out.println(intOnly.validator.isValid("123ab"));

            GreaterThanFourValidatorTest greater4Only = (GreaterThanFourValidatorTest) context.getBean("GreaterThanFourTest");
            System.out.println(greater4Only.validator.isValid(10));
            System.out.println(greater4Only.validator.isValid(1));
        }
    }
}

bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="GreaterThanFour" class="com.compare.GreaterThanFourValidator" />

    <bean id="IntegerOnly" class="com.compare.IntegerOnlyValidator" />

    <bean id="GreaterThanFourTest" class="com.compare.GreaterThanFourValidatorTest">
        <property name="validator">
            <ref local="GreaterThanFour"/>
        </property>
    </bean>

    <bean id="IntegerOnlyTest" class="com.compare.IntegerOnlyValidatorTest">
        <property name="validator">
            <ref local="IntegerOnly"/>
        </property>
    </bean>
</beans>

Dependency Injection Pattern in Java using Spring (Part 3)

Posted on by

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany.app</groupId>
    <artifactId>my-module</artifactId>
    <version>1</version>
 
    <dependencies>
		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.2.2.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <defaultGoal>compile</defaultGoal>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.5.1</version>
                <executions>
                    <execution>
                        <id>copy1</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>.\lib</outputDirectory>
                            <!-- other configurations here -->
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

IPerson.java

package conferenceRoom;

public interface IPerson {
    String getName();
}

Person.java

package conferenceRoom;

public class Person implements IPerson{
	 
    String name = "default";
 
    public Person(String name)
    {
        this.name = name;
    }
 
    @Override
    public String getName() {
        return name;
    }
}

IConferenceRoom.java

package conferenceRoom;

public interface IConferenceRoom
{
    IPerson[] getPeople();
}

ConferenceRoom.java

package conferenceRoom;

public class ConferenceRoom implements IConferenceRoom {

	IPerson[] people;
	public ConferenceRoom(IPerson[] people)
    {
        this.people = people;
    }
	
	@Override
	public IPerson[] getPeople() {
		return people;
	}

}

Work.java

package conferenceRoom;

public class Work {
	IConferenceRoom conferenceRoom1;
	IConferenceRoom conferenceRoom2;
	
	public IConferenceRoom getConferenceRoom1() {
		return conferenceRoom1;
	}
	public void setConferenceRoom1(IConferenceRoom conferenceRoom1) {
		this.conferenceRoom1 = conferenceRoom1;
	}
	public IConferenceRoom getConferenceRoom2() {
		return conferenceRoom2;
	}
	public void setConferenceRoom2(IConferenceRoom conferenceRoom2) {
		this.conferenceRoom2 = conferenceRoom2;
	}
}

Main.java

package conferenceRoom;

import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Main {
 
    public static void main(String[] args) {
        try(ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml")) {
            Work work = (Work)context.getBean("Work");
            
            System.out.println("People at conference room 1");
            for(IPerson p : work.getConferenceRoom1().getPeople())
            {
            	System.out.println(p.getName());
            }
            
            System.out.println();
            System.out.println("People at conference room 2");
            for(IPerson p : work.getConferenceRoom2().getPeople())
            {
            	System.out.println(p.getName());
            }
            
            IConferenceRoom outOfTheBlue = (IConferenceRoom)context.getBean("conferenceRoom_OutofTheBlue");
            work.setConferenceRoom2(outOfTheBlue);
            
            System.out.println();
            System.out.println("People at conference room 1");
            for(IPerson p : work.getConferenceRoom1().getPeople())
            {
            	System.out.println(p.getName());
            }
            
            System.out.println();
            System.out.println("People at conference room 2");
            for(IPerson p : work.getConferenceRoom2().getPeople())
            {
            	System.out.println(p.getName());
            }
        }
    }
}

bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <bean id="John" class="conferenceRoom.Person">
        <constructor-arg>
            <value>John</value>
        </constructor-arg>
    </bean>
 
    <bean id="Catherine" class="conferenceRoom.Person">
        <constructor-arg>
            <value>Catherine</value>
        </constructor-arg>
    </bean>
 
     <bean id="Ben" class="conferenceRoom.Person">
        <constructor-arg>
            <value>Ben</value>
        </constructor-arg>
    </bean>

     <bean id="Elizabeth" class="conferenceRoom.Person">
        <constructor-arg>
            <value>Elizabeth</value>
        </constructor-arg>
    </bean>
    
     <bean id="Jennifer" class="conferenceRoom.Person">
        <constructor-arg>
            <value>Jennifer</value>
        </constructor-arg>
    </bean>
    
     <bean id="Michael" class="conferenceRoom.Person">
        <constructor-arg>
            <value>Michael</value>
        </constructor-arg>
    </bean>
    
    <bean id="conference1" class="conferenceRoom.ConferenceRoom">
        <constructor-arg>
            <array value-type="conferenceRoom.IPerson">
            	<ref local="John"/>
            	<ref local="Catherine" />
        	</array>
        </constructor-arg>
    </bean>
    
    <bean id="conference2" class="conferenceRoom.ConferenceRoom">
        <constructor-arg>
            <array value-type="conferenceRoom.IPerson">
            	<ref local="Ben"/>
            	<ref local="Elizabeth" />
        	</array>
        </constructor-arg>
    </bean>
    
    <bean id="conferenceRoom_OutofTheBlue" class="conferenceRoom.ConferenceRoom">
        <constructor-arg>
            <array value-type="conferenceRoom.IPerson">
            	<ref local="Jennifer"/>
            	<ref local="Michael" />
        	</array>
        </constructor-arg>
    </bean>
    
    <bean id="Work" class="conferenceRoom.Work">
        <property name="conferenceRoom1">
        	<ref local="conference1" />
        </property>
        <property name="conferenceRoom2">
        	<ref local="conference2" />
        </property>
    </bean>
</beans>

Dependency Injection Pattern in Java using Spring (Part 2)

Posted on by

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany.app</groupId>
    <artifactId>my-module</artifactId>
    <version>1</version>
 
    <dependencies>
		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.2.2.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <defaultGoal>compile</defaultGoal>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.5.1</version>
                <executions>
                    <execution>
                        <id>copy1</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>.\lib</outputDirectory>
                            <!-- other configurations here -->
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

IPerson.java

package work;

public interface IPerson {
    String getName();
}

Person.java

package work;

public class Person implements IPerson{

    String name = "default";

    public Person(String name)
    {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }
}

Work.java

package work;

public class Work {
    IPerson office1;
    IPerson office2;

    public IPerson getOffice1() {
        return office1;
    }

    public void setOffice1(IPerson office1) {
        this.office1 = office1;
    }

    public IPerson getOffice2() {
        return office2;
    }

    public void setOffice2(IPerson office2) {
        this.office2 = office2;
    }
}

Main.java

package work;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {
        try(ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml")) {
	        Work work = (Work)context.getBean("Work");
	        System.out.println(work.getOffice1().getName() + " is at office 1");
	        System.out.println(work.getOffice2().getName() + " is at office 2");
        }
    }
}

bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="John" class="work.Person">
        <constructor-arg>
            <value>John</value>
        </constructor-arg>
    </bean>

    <bean id="Catherine" class="work.Person">
        <constructor-arg>
            <value>Catherine</value>
        </constructor-arg>
    </bean>

    <bean id="Work" class="work.Work">
        <property name="office1">
            <ref local="John"/>
        </property>
        <property name="office2">
            <ref local="Catherine"/>
        </property>
    </bean>
</beans>

Dependency Injection Pattern in C# using Unity (part 4)

Posted on by

Program.cs

using Microsoft.Practices.Unity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace validator
{
    interface IValidator<T>
    {
        bool isValid(T instance);
    }

    class IntegerOnlyValidator : IValidator<string>
    {
        public bool isValid(string instance)
        {
            int i = 0;
            return Int32.TryParse(instance, out i);
        }
    }

    class IntegerOnlyValidatorTest
    {
        [Dependency("validator")]
        public IValidator<string> validator { get; set; }
    }

    class GreaterThanFourValidator : IValidator<int>
    {
        public bool isValid(int instance)
        {
            return instance > 4;
        }
    }

    class GreaterThanFourValidatorTest
    {
        [Dependency("validator")]
        public IValidator<int> validator { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            using (IUnityContainer container = new UnityContainer())
            {
                container.RegisterType<IValidator<string>, IntegerOnlyValidator>("validator");
                IntegerOnlyValidatorTest intOnly = container.Resolve<IntegerOnlyValidatorTest>();
                Console.WriteLine(intOnly.validator.isValid("5554"));
                Console.WriteLine(intOnly.validator.isValid("123ab"));
                
                container.RegisterType<IValidator<int>, GreaterThanFourValidator>("validator");
                GreaterThanFourValidatorTest greater4Only = container.Resolve<GreaterThanFourValidatorTest>();
                Console.WriteLine(greater4Only.validator.isValid(10));
                Console.WriteLine(greater4Only.validator.isValid(1));
            }
        }
    }
}

Dependency Injection via config file
Note: Add reference “System.Configuration”
App.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="unity"
             type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration"/>
  </configSections>
  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <assembly name="validator"/>
    <namespace name="validator"/>

    <container>
      <register name="integeronly" type="IValidator[string]" mapTo="IntegerOnlyValidator" />
      <register name="greaterthan4" type="IValidator[int]" mapTo="GreaterThanFourValidator" />
      <register type="IntegerOnlyValidatorTest">
        <property name="validator">
          <dependency name="integeronly" />
        </property>
      </register>
      <register type="GreaterThanFourValidatorTest">
        <property name="validator">
          <dependency name="greaterthan4" />
        </property>
      </register>
    </container>
  </unity>
</configuration>

Program.cs

using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace validator
{
    interface IValidator<T>
    {
        bool isValid(T instance);
    }

    class IntegerOnlyValidator : IValidator<string>
    {
        public bool isValid(string instance)
        {
            int i = 0;
            return Int32.TryParse(instance, out i);
        }
    }

    class IntegerOnlyValidatorTest
    {
        [Dependency("validator")]
        public IValidator<string> validator { get; set; }
    }

    class GreaterThanFourValidator : IValidator<int>
    {
        public bool isValid(int instance)
        {
            return instance > 4;
        }
    }

    class GreaterThanFourValidatorTest
    {
        [Dependency("validator")]
        public IValidator<int> validator { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            using (IUnityContainer container = new UnityContainer())
            {
                container.LoadConfiguration();

                IntegerOnlyValidatorTest intOnly = container.Resolve<IntegerOnlyValidatorTest>();
                Console.WriteLine(intOnly.validator.isValid("5554"));
                Console.WriteLine(intOnly.validator.isValid("123ab"));

                GreaterThanFourValidatorTest greater4Only = container.Resolve<GreaterThanFourValidatorTest>();
                Console.WriteLine(greater4Only.validator.isValid(10));
                Console.WriteLine(greater4Only.validator.isValid(1));
            }
        }
    }
}

Dependency Injection Pattern in C# using Unity (part 3)

Posted on by

Program.cs

using Microsoft.Practices.Unity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace work
{
    interface IPerson
    {
        string Name { get; }
    }

    class Person : IPerson
    {
        [InjectionConstructor]
        public Person(string name)
        {
            this.name = name;
        }

        string name = "default";
        public string Name
        {
            get
            {
                return name;
            }
        }
    }

    interface IConferenceRoom
    {
        IPerson[] People { get; }
    }

    class ConferenceRoom : IConferenceRoom
    {
        IPerson[] people;
        public ConferenceRoom(IPerson[] people)
        {
            this.people = people;
        }

        public IPerson[] People
        {
            get
            {
                return people;
            }
        }
    }

    class Work
    {
        [Dependency("conferenceRoom1")]
        public IConferenceRoom conferenceRoom1 { get; set; }
        [Dependency("conferenceRoom2")]
        public IConferenceRoom conferenceRoom2 { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            using (IUnityContainer container = new UnityContainer())
            {
                container.RegisterType<IPerson, Person>("John", new InjectionConstructor("John"));
                container.RegisterType<IPerson, Person>("Catherine", new InjectionConstructor("Catherine"));
                container.RegisterType<IConferenceRoom, ConferenceRoom>("conferenceRoom1",
                    new InjectionConstructor(new ResolvedArrayParameter<IPerson>(
                        new ResolvedParameter<IPerson>("John"),
                        new ResolvedParameter<IPerson>("Catherine"))));

                container.RegisterType<IPerson, Person>("Ben", new InjectionConstructor("Ben"));
                container.RegisterType<IPerson, Person>("Elizabeth", new InjectionConstructor("Elizabeth"));
                container.RegisterType<IConferenceRoom, ConferenceRoom>("conferenceRoom2",
                    new InjectionConstructor(new ResolvedArrayParameter<IPerson>(
                        new ResolvedParameter<IPerson>("Ben"),
                        new ResolvedParameter<IPerson>("Elizabeth"))));

                Work w = container.Resolve<Work>();

                Console.WriteLine("People at conference room 1");
                foreach (IPerson p in w.conferenceRoom1.People)
                {
                    Console.WriteLine(p.Name);
                }

                Console.WriteLine();

                Console.WriteLine("People at conference room 2");
                foreach (IPerson p in w.conferenceRoom2.People)
                {
                    Console.WriteLine(p.Name);
                }

                container.RegisterType<IPerson, Person>("Jennifer", new InjectionConstructor("Jennifer"));
                container.RegisterType<IPerson, Person>("Michael", new InjectionConstructor("Michael"));

                container.RegisterType<IConferenceRoom, ConferenceRoom>("conferenceRoom_OutofTheBlue",
                    new InjectionConstructor(new ResolvedArrayParameter<IPerson>(
                        new ResolvedParameter<IPerson>("Jennifer"),
                        new ResolvedParameter<IPerson>("Michael"))));
                w = container.Resolve<Work>(
                        new PropertyOverride("conferenceRoom2", new ResolvedParameter<IConferenceRoom>("conferenceRoom_OutofTheBlue")));

                Console.WriteLine();

                Console.WriteLine("People at conference room 1");
                foreach (IPerson p in w.conferenceRoom1.People)
                {
                    Console.WriteLine(p.Name);
                }

                Console.WriteLine();

                Console.WriteLine("People at conference room 2");
                foreach (IPerson p in w.conferenceRoom2.People)
                {
                    Console.WriteLine(p.Name);
                }
            }
        }
    }
}

Dependency Injection via config file
App.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="unity"
             type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration"/>
  </configSections>
  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <assembly name="work"/>
    <namespace name="work"/>

    <container>
      <register name="John" type="IPerson" mapTo="Person">
        <constructor>
          <param name="name" value="John" />
        </constructor>
      </register>
      <register name="Catherine" type="IPerson" mapTo="Person">
        <constructor>
          <param name="name" value="Catherine" />
        </constructor>
      </register>
      <register name="Ben" type="IPerson" mapTo="Person">
        <constructor>
          <param name="name" value="Ben" />
        </constructor>
      </register>
      <register name="Elizabeth" type="IPerson" mapTo="Person">
        <constructor>
          <param name="name" value="Elizabeth" />
        </constructor>
      </register>
      <register name="Jennifer" type="IPerson" mapTo="Person">
        <constructor>
          <param name="name" value="Jennifer" />
        </constructor>
      </register>
      <register name="Michael" type="IPerson" mapTo="Person">
        <constructor>
          <param name="name" value="Michael" />
        </constructor>
      </register>
      <register name="conferenceRoom1" type="IConferenceRoom" mapTo="ConferenceRoom">
        <constructor>
          <param name="peopleArg">
            <array>
              <dependency name="John"/>
              <dependency name="Catherine"/>
            </array>
          </param>
        </constructor>
      </register>
      <register name="conferenceRoom2" type="IConferenceRoom" mapTo="ConferenceRoom">
        <constructor>
          <param name="peopleArg">
            <array>
              <dependency name="Ben"/>
              <dependency name="Elizabeth"/>
            </array>
          </param>
        </constructor>
      </register>
      <register name="conferenceRoom_OutofTheBlue" type="IConferenceRoom" mapTo="ConferenceRoom">
        <constructor>
          <param name="peopleArg">
            <array>
              <dependency name="Jennifer"/>
              <dependency name="Michael"/>
            </array>
          </param>
        </constructor>
      </register>
      <register type="Work">
        <property name="conferenceRoom1">
          <dependency name="conferenceRoom1" />
        </property>
        <property name="conferenceRoom2">
          <dependency name="conferenceRoom2" />
        </property>
      </register>
    </container>
  </unity>
</configuration>

Program.cs

using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace work
{
    interface IPerson
    {
        string Name { get; }
    }

    class Person : IPerson
    {
        [InjectionConstructor]
        public Person(string name)
        {
            this.name = name;
        }

        string name = "default";
        public string Name
        {
            get
            {
                return name;
            }
        }
    }

    interface IConferenceRoom
    {
        IPerson[] People { get; }
    }

    class ConferenceRoom : IConferenceRoom
    {
        IPerson[] people;
        public ConferenceRoom(IPerson[] peopleArg)
        {
            this.people = peopleArg;
        }

        public IPerson[] People
        {
            get
            {
                return people;
            }
        }
    }

    class Work
    {
        [Dependency("conferenceRoom1")]
        public IConferenceRoom conferenceRoom1 { get; set; }
        [Dependency("conferenceRoom2")]
        public IConferenceRoom conferenceRoom2 { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            using (IUnityContainer container = new UnityContainer())
            {
                container.LoadConfiguration();
                Work w = container.Resolve();

                Console.WriteLine("People at conference room 1");
                foreach (IPerson p in w.conferenceRoom1.People)
                {
                    Console.WriteLine(p.Name);
                }

                Console.WriteLine();

                Console.WriteLine("People at conference room 2");
                foreach (IPerson p in w.conferenceRoom2.People)
                {
                    Console.WriteLine(p.Name);
                }

                w = container.Resolve(new PropertyOverride("conferenceRoom2", 
                    new ResolvedParameter("conferenceRoom_OutofTheBlue")));

                Console.WriteLine();

                Console.WriteLine("People at conference room 1");
                foreach (IPerson p in w.conferenceRoom1.People)
                {
                    Console.WriteLine(p.Name);
                }

                Console.WriteLine();

                Console.WriteLine("People at conference room 2");
                foreach (IPerson p in w.conferenceRoom2.People)
                {
                    Console.WriteLine(p.Name);
                }
            }
        }
    }
}

Palindrome in Scala

Posted on by

Solution to Project Euler problem 4

package problem4

object problem4 {
  def isPalindrome(x: String) : Boolean = {
    var i = 0
    var j = x.length() - 1
    
    while(i <= j) {
      if (x.charAt(i) != x.charAt(j))
        return false
        
        i += 1
        j -= 1
    }
    return true
  }

  def main(args: Array[String]): Unit = {
    var max = 0
    for(i <- 100 to 1000) {
      for(j <- 100 to 1000) {
        var prod = i * j
        var prodStr = prod.toString()
        if (isPalindrome(prodStr)) {
          max = Math.max(max, prod)
        }
      }
    }
    
    println(max)
  }
}

Palindrome in C++

Posted on by

Solution to Project Euler problem 4

#include<iostream>
using namespace std;

bool isPalindrome(char* x);

int main()
{
	char prodStr[100];
    int max = 0;
    int i, j, prod;
    for (i = 100; i < 1000; i++)
    {
        for (j = 100; j < 1000; j++)
        {
            prod = i * j;
            sprintf_s(prodStr, 100, "%i", prod);
            if(isPalindrome(prodStr) == 1)
            {
                if(prod > max)
                    max = prod;
            }
        }
    }
	cout<<max<<endl;
    return 0;
}

bool isPalindrome(char* x)
{
    int i = 0;
    int j = strlen(x) - 1;
 
    while (i <= j)
    {
        if (x[i] != x[j])
            return false;
        i++;
        j--;
    }
 
    return true;
}

Palindrome in Objective-C

Posted on by

Solution to Project Euler problem 4

#import <Foundation/Foundation.h>

bool isPalindrome(NSString *x)
{
    NSInteger i = 0;
    NSUInteger j = [x length] - 1;
    while (i <= j)
    {
        if ([x characterAtIndex:i] != [x characterAtIndex:j])
            return false;
        i++;
        j--;
    }
    return true;
}

int main(int argc, const char * argv[])
{
    @autoreleasepool {
        int max = 0;
        for (int i = 100; i < 1000; i++) {
            for (int j = 100; j < 1000; j++) {
                int prod = i * j;
                NSString *prodStr = [NSString stringWithFormat:@"%i", prod];
                if (isPalindrome(prodStr) && prod > max) {
                    max = prod;
                }
            }
        }
        
        NSLog(@"%i", max);
    }
    return 0;
}

Palindrome in C

Posted on by

Solution to Project Euler problem 4

#include<stdio.h>
#include<string.h>
#include<math.h>

int isPalindrome(char* x);

int main()
{
	char prodStr[100];
	int max = 0;
	int i, j, prod;
	for (i = 100; i < 1000; i++)
	{
		for (j = 100; j < 1000; j++)
		{
			prod = i * j;
			sprintf_s(prodStr, 100, "%i", prod);
			if(isPalindrome(prodStr) == 1)
			{
				if(prod > max)
					max = prod;
			}
		}
	}
	printf("%i\n", max);
	return 0;
}

int isPalindrome(char* x)
{
	int i = 0;
	int j = strlen(x) - 1;

	while (i <= j)
	{
		if (x[i] != x[j])
			return 0;
		i++;
		j--;
	}

	return 1;
}

Palindrome in Java

Posted on by

Solution to Project Euler problem 4

package projectEuler;

public class Problem4 {

	static boolean isPalindrome(String x)
    {
        int i = 0;
        int j = x.length() - 1;
        while (i <= j)
        {
            if (x.charAt(i) != x.charAt(j))
                return false;
            i++;
            j--;
        }

        return true;
    }
	
	public static void main(String[] args) {
		int max = 0;
        for (int i = 100; i < 1000; i++)
        {
            for (int j = 100; j < 1000; j++)
            {
                Integer prod = i * j;
                String prodStr = prod.toString();
                if(isPalindrome(prodStr))
                    max = Math.max(max, prod);
            }
        }
        System.out.println(max);
	}

}