Manual Custom Connection without having to leave the application

Sorry, I have not. I should have time next week.

test by your self (Cocktail ver 19545) I'll only take 2 minutes

namespace Common {
    public interface IUserSession   {
        string Name { get; set; }
    }
}
namespace Common{
    [Export(typeof(IUserSession)), PartCreationPolicy(CreationPolicy.Shared)]
    public class UserSession : IUserSession    {
        private string _name;
        public UserSession()        {        }
        public string Name {
            get { return _name; }
            set { _name = value; }
        }
    }
}
namespace TempHire {
  public class CustomDataSourceKeyResolver : IDataSourceKeyResolver {
    public IdeaBlade.EntityModel.IDataSourceKey GetKey(string keyName, string keyExtension, bool onServer) {
      if (!onServer) { return null; }
      if (string.IsNullOrEmpty(keyExtension)) { return null; }
      if (keyName != "TempHireEntities") { return null; }
      String connectionString = "";
      if (keyExtension == "PROD")      {          connectionString = @"Data Source=|DataDirectory|TempHire_Prod.sdf";      }
      if (keyExtension == "TEST")      {          connectionString = @"Data Source=|DataDirectory|TempHire_Test.sdf";      }    
      string name = string.IsNullOrEmpty(keyExtension) ? keyName : keyName + "_" + keyExtension;
      return new ClientEdmKey(name, connectionString, false, "FromResolver");
    }
  }
}
namespace TempHire {
    public class EnvironmentResolver : IConnectionOptionsResolver    {
        private static ConnectionOptions TestEnv = ConnectionOptions.Default.WithDataSourceExtension("TEST");
        private static ConnectionOptions ProdEnv = ConnectionOptions.Default.WithDataSourceExtension("PROD");
        private IUserSession _userSession;
        [ImportingConstructor]
        public EnvironmentResolver(IUserSession userSession)  {
            _userSession = userSession;
        }
        public ConnectionOptions GetConnectionOptions(string name)   {   
            if (name == ConnectionOptions.Default.Name)  {
                    switch (_userSession.Name)  {
                        case "Test": return TestEnv.WithName(ConnectionOptions.Default.Name);
                        case "Prod": return ProdEnv.WithName(ConnectionOptions.Default.Name);

                        default: return null;
                    }
                    //return ConnectionOptions.Default.WithDataSourceExtension(_userSession.Name.ToUpper()).WithName(ConnectionOptions.Default.Name);
                }
            return null;
        }
    }
}

namespace TempHire.ViewModels.Login
{  using System.Linq;

    [Export]
    public class LoginViewModel : Screen, IResult   {
        .......
        private IUserSession _userSession;
        private string _displayMemberPath;
        private BindableCollection<object> _items;
        private object _selectedItem;

        [ImportingConstructor]
        public LoginViewModel(IAuthenticationService authenticationService, IWindowManager windowManager,
                              [Import(AllowDefault = true)] IGlobalCache globalCache, IUserSession userSession)    {
            _userSession = userSession;
            DisplayMemberPath = "WithName";
            Items = new BindableCollection<object>() { new Connections() { WithName = "Test" }, new Connections() { WithName = "Prod" } };
        }
        private class Connections   {
            public Connections() { }
            public string WithName { get; set; }
        }       
        public string DisplayMemberPath        {
            get { return _displayMemberPath; }
            set  {
                _displayMemberPath = value;
                NotifyOfPropertyChange(() => DisplayMemberPath);
            }
        }
        public object SelectedItem        {
            get { return _selectedItem; }
            set  {
                _selectedItem = value;
                NotifyOfPropertyChange(() => SelectedItem);
                _userSession.Name = ((Connections)SelectedItem).WithName;
            }
        }
        public BindableCollection<object> Items    {
            get { return _items; }
            set     {
                _items = value;
                NotifyOfPropertyChange(() => Items);
                SelectedItem = _items.FirstOrDefault();
            }
        }

           LoginView after password
            <ComboBox x:Name="Items"
                  Grid.Row="3" Grid.Column="1"
                  Height="25"
                  Margin="2,2,81,2"
                  VerticalAlignment="Center"
                  DisplayMemberPath="{Binding DisplayMemberPath}" Width="137" />

I put a TextBlock in StaffingResourceAddressListView
  <TextBlock Text="{Binding Item.StateId}" />

everything work fine
ComboBox have problem

<ComboBox Grid.Row="4"
                                  Grid.Column="1"
                                  Width="140"
                                  Height="25"
                                  Margin="2"
                                  HorizontalAlignment="Left"
                                  DisplayMemberPath="Name"
                                  ItemsSource="{Binding ElementName=LayoutRoot,
                                                        Path=DataContext.States}"
                                  MaxDropDownHeight="200"
                                  SelectedValue="{Binding Item.StateId,
                                                          ValidatesOnDataErrors=True,
                                                          ValidatesOnExceptions=True,
                                                          Mode=TwoWay}"
                                  SelectedValuePath="Id" />
 

After selecting base (Prod) and connect all is well
When after changing the base(Test) the combobox(State) from Adresses are not filled,
If we go back to first base again all well

thank you very much
Also when we change the connection not fill the comboboxes at second database,
when change again the first database the comboboxes is correct why?

perfect
I noticed when  GetConnectionOptions take value is always "Default" and ConnectionOptions.Default.Name having the same value , always , that is correct?
because in this case we do not need to check out.

Also when we change the connection not fill the comboboxes at second database,
when change again the first database the comboboxes is correct


Edited by giotis - 04-Sep-2012 at 10:46pm

Dear Marcel so far no so good,

my steps

a. public interface IUserSession   {
        string Name { get; set; }
    }

    [Export(typeof(IUserSession)), PartCreationPolicy(CreationPolicy.Shared)]
    public class UserSession : IUserSession    {
        public UserSession()        {   }
        public string Name { get; set; }
    }

b.public class EnvironmentResolver : IConnectionOptionsResolver  {     
        public ConnectionOptions GetConnectionOptions(string name)
        {
            IUserSession userSession = Composition.GetInstance<IUserSession>(CreationPolicy.Shared);
            if (name == userSession.Name)
                return ConnectionOptions.Default.WithDataSourceExtension(
                                userSession.Name.ToUpper()).WithName(userSession.Name);
            return null;
        }
    }
c. <connectionStrings>
      <add name="SecurityEntities" connectionString=...
  </connectionStrings>

d.class CustomDataSourceKeyResolver : IDataSourceKeyResolver {
    public GetKey(string keyName, string keyExtension, bool onServer) {
      if (!onServer) {return null;}
      if (keyName != "TempHireEntities" || string.IsNullOrEmpty(keyExtension)) { return null; }
      String connectionString = "";
      if (keyExtension == "PROD")   {
          connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=TempHire_Production; ...
      }
      if (keyExtension == "TEST")    {
          connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=TempHire_Test; ...
      }

      if(string.IsNullOrEmpty(connectionString ) { return null; }

      // Now build and return a "ClientEdmKey". 
      string name = string.IsNullOrEmpty(keyExtension) ? keyName : keyName + "_" + keyExtension;
      return new ClientEdmKey(name, connectionString, false, "FromResolver");
    }
  }

e.[Export]
    public IEntityManagerProvider<TempHireEntities> TempHireEntityManagerProvider    {
            get    {
                IUserSession userSession = Composition.GetInstance<IUserSession>(CreationPolicy.Shared);
                var provider = new EntityManagerProvider<TempHireEntities>()
                    .Configure(config => config.WithConnectionOptions(userSession.Name));
                return provider;
            }
        }

f. [ImportingConstructor]
   public LoginViewModel(IAuthenticationService authenticationService, IWindowManager windowManager,
                              [Import(AllowDefault = true)] IPreLoader preLoader, IUserSession userSession
           ....
            _userSession = userSession;
           ....

   _userSession.Name = filled from one new field named KeyName
    public string KeyName
        {
            get { return _keyName; }
            set
            {
                _keyName= value;
                _userSession.Name = value;
                NotifyOfPropertyChange(() => KeyName);
                NotifyOfPropertyChange(() => CanLogin);
            }
        }


g. before Login
    public IEnumerable<IResult> Login()  {
            _authenticationService. ??? There is no implementation to configure ConnectionOptions
            using (Busy.GetTicket()) ...

I am stuck

ps. If CustomDataSourceKeyResolver return null how can it manage from LoginViewModel

DataSourceKeyResolver run only once, how do I switch?